Full Code of mozilla/sccache for AI

gitextract__oh_a4dj/

├── .envrc
├── .github/
│   ├── actions/
│   │   ├── artifact_failure/
│   │   │   └── action.yml
│   │   ├── nvcc-toolchain/
│   │   │   ├── action.yml
│   │   │   ├── install-cuda.ps1
│   │   │   └── install-cuda.sh
│   │   └── rust-toolchain/
│   │       └── action.yml
│   ├── codecov.yml
│   ├── dependabot.yml
│   └── workflows/
│       ├── benchmarks.yml
│       ├── ci.yml
│       ├── close-snap.yml
│       ├── integration-tests.yml
│       └── snap.yml
├── .gitignore
├── .pre-commit-config.yaml
├── .rustfmt.toml
├── .taplo.toml
├── CODE_OF_CONDUCT.md
├── Cargo.toml
├── LICENSE
├── README.md
├── benches/
│   └── sccache_bench.rs
├── docs/
│   ├── Architecture.md
│   ├── Azure.md
│   ├── COS.md
│   ├── Caching.md
│   ├── Configuration.md
│   ├── Distributed.md
│   ├── DistributedFreeBSD.md
│   ├── DistributedQuickstart.md
│   ├── GHA.md
│   ├── Gcs.md
│   ├── Jenkins.md
│   ├── Local.md
│   ├── Memcached.md
│   ├── OSS.md
│   ├── Redis.md
│   ├── Releasing.md
│   ├── ResponseFiles.md
│   ├── Rust.md
│   ├── S3.md
│   ├── Webdav.md
│   └── Xcode.md
├── flake.nix
├── scripts/
│   ├── extratest.sh
│   └── freebsd-ci-test.sh
├── snap/
│   └── snapcraft.yaml
├── src/
│   ├── bin/
│   │   └── sccache-dist/
│   │       ├── build.rs
│   │       ├── build_freebsd.rs
│   │       ├── cmdline/
│   │       │   ├── mod.rs
│   │       │   └── parse.rs
│   │       ├── main.rs
│   │       └── token_check.rs
│   ├── cache/
│   │   ├── azure.rs
│   │   ├── cache.rs
│   │   ├── cache_io.rs
│   │   ├── cos.rs
│   │   ├── disk.rs
│   │   ├── gcs.rs
│   │   ├── gha.rs
│   │   ├── http_client.rs
│   │   ├── lazy_disk_cache.rs
│   │   ├── memcached.rs
│   │   ├── mod.rs
│   │   ├── oss.rs
│   │   ├── readonly.rs
│   │   ├── redis.rs
│   │   ├── s3.rs
│   │   ├── utils.rs
│   │   └── webdav.rs
│   ├── client.rs
│   ├── cmdline.rs
│   ├── commands.rs
│   ├── compiler/
│   │   ├── args.rs
│   │   ├── c.rs
│   │   ├── cicc.rs
│   │   ├── clang.rs
│   │   ├── compiler.rs
│   │   ├── counted_array.rs
│   │   ├── cudafe.rs
│   │   ├── diab.rs
│   │   ├── gcc.rs
│   │   ├── mod.rs
│   │   ├── msvc.rs
│   │   ├── nvcc.rs
│   │   ├── nvhpc.rs
│   │   ├── preprocessor_cache.rs
│   │   ├── ptxas.rs
│   │   ├── rust.rs
│   │   └── tasking_vx.rs
│   ├── config.rs
│   ├── dist/
│   │   ├── cache.rs
│   │   ├── client_auth.rs
│   │   ├── http.rs
│   │   ├── mod.rs
│   │   ├── pkg.rs
│   │   └── test.rs
│   ├── errors.rs
│   ├── jobserver.rs
│   ├── lib.rs
│   ├── lru_disk_cache/
│   │   ├── lru_cache.rs
│   │   └── mod.rs
│   ├── main.rs
│   ├── mock_command.rs
│   ├── net.rs
│   ├── protocol.rs
│   ├── server.rs
│   ├── test/
│   │   ├── mock_storage.rs
│   │   ├── mod.rs
│   │   ├── tests.rs
│   │   └── utils.rs
│   └── util.rs
└── tests/
    ├── cache_hit_rate.rs
    ├── cmake-modules/
    │   ├── CMakeLists.txt
    │   ├── main.cpp
    │   └── mymodule.cppm
    ├── dist.rs
    ├── harness/
    │   ├── Dockerfile.sccache-dist
    │   └── mod.rs
    ├── helpers/
    │   └── mod.rs
    ├── integration/
    │   ├── Makefile
    │   ├── README.md
    │   ├── autotools/
    │   │   ├── Makefile.am
    │   │   ├── configure.ac
    │   │   └── main.cpp
    │   ├── basedirs-autotools/
    │   │   ├── Makefile.am
    │   │   ├── configure.ac
    │   │   ├── include/
    │   │   │   └── myheader.h
    │   │   └── main.cpp
    │   ├── cmake/
    │   │   ├── CMakeLists.txt
    │   │   └── main.cpp
    │   ├── cmake-hip/
    │   │   ├── CMakeLists.txt
    │   │   └── vectoradd_hip.cpp
    │   ├── docker-compose.yml
    │   ├── msvc/
    │   │   ├── args.rsp
    │   │   └── foo.cpp
    │   ├── msvc-preprocessing/
    │   │   ├── args.rsp
    │   │   └── foo.cpp
    │   ├── randomize_readdir/
    │   │   ├── Cargo.toml
    │   │   └── src/
    │   │       └── lib.rs
    │   ├── scripts/
    │   │   ├── test-autotools.sh
    │   │   ├── test-backend.sh
    │   │   ├── test-basedirs.sh
    │   │   ├── test-clang.sh
    │   │   ├── test-cmake.sh
    │   │   ├── test-coverage.sh
    │   │   ├── test-gcc.sh
    │   │   └── test-zstd.sh
    │   ├── test_intel_asm.s
    │   ├── test_intel_asm_to_preproc.S
    │   ├── webdav-config.yaml
    │   └── xcode/
    │       ├── main.cpp
    │       ├── sccache.xcconfig
    │       └── xcode-test.xcodeproj/
    │           └── project.pbxproj
    ├── logging.rs
    ├── msvc-msbuild/
    │   ├── .gitignore
    │   ├── MsbuildCpp.vcxproj
    │   ├── test_bar.cpp
    │   ├── test_baz.cpp
    │   └── test_foo.cpp
    ├── oauth.rs
    ├── sccache_args.rs
    ├── sccache_cargo.rs
    ├── sccache_rustc.rs
    ├── system.rs
    ├── test-crate/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── bin.rs
    │       └── lib.rs
    ├── test.c
    ├── test.c.gcc-13.2.0-preproc
    ├── test_a.cu
    ├── test_a.hip
    ├── test_b.cu
    ├── test_b.hip
    ├── test_c.cu
    ├── test_c.hip
    ├── test_clang_multicall.c
    ├── test_err.c
    ├── test_macro_expansion.c
    ├── test_whitespace.c
    ├── test_whitespace_alt.c
    └── test_with_define.c

SYMBOL INDEX (2294 symbols across 93 files)

FILE: benches/sccache_bench.rs
  function generate_test_data (line 33) | fn generate_test_data(size: usize) -> Vec<u8> {
  function generate_preprocessor_output (line 45) | fn generate_preprocessor_output(num_lines: usize) -> Vec<u8> {
  function generate_data_with_time_macros (line 68) | fn generate_data_with_time_macros(size: usize) -> Vec<u8> {
  function hash_large_data (line 86) | fn hash_large_data(bencher: Bencher) {
  function time_macro_finder_no_macros (line 101) | fn time_macro_finder_no_macros(bencher: Bencher) {
  function time_macro_finder_with_macros (line 112) | fn time_macro_finder_with_macros(bencher: Bencher) {
  function time_macro_finder_chunked (line 123) | fn time_macro_finder_chunked(bencher: Bencher) {
  function lru_cache_insert (line 143) | fn lru_cache_insert(bencher: Bencher) {
  function lru_cache_get_hit (line 162) | fn lru_cache_get_hit(bencher: Bencher) {
  function lru_cache_eviction (line 184) | fn lru_cache_eviction(bencher: Bencher) {
  function lru_cache_mixed_workload (line 206) | fn lru_cache_mixed_workload(bencher: Bencher) {
  function simulate_hash_key (line 241) | fn simulate_hash_key(
  function cache_key_generation (line 276) | fn cache_key_generation(bencher: Bencher) {
  function generate_object_file (line 320) | fn generate_object_file(size: usize) -> Vec<u8> {
  function cache_entry_create_small (line 331) | fn cache_entry_create_small(bencher: Bencher) {
  function cache_entry_create_large (line 350) | fn cache_entry_create_large(bencher: Bencher) {
  function cache_entry_roundtrip_small (line 369) | fn cache_entry_roundtrip_small(bencher: Bencher) {
  function cache_entry_roundtrip_large (line 394) | fn cache_entry_roundtrip_large(bencher: Bencher) {
  function cache_entry_batch_create (line 421) | fn cache_entry_batch_create(bencher: Bencher) {
  function cache_entry_batch_roundtrip (line 442) | fn cache_entry_batch_roundtrip(bencher: Bencher) {
  function hash_header_file (line 480) | fn hash_header_file(bencher: Bencher) {
  function hash_multiple_files (line 492) | fn hash_multiple_files(bencher: Bencher) {
  function build_workflow_initial (line 516) | fn build_workflow_initial(bencher: Bencher) {
  function build_workflow_rebuild (line 545) | fn build_workflow_rebuild(bencher: Bencher) {
  function build_workflow_incremental (line 586) | fn build_workflow_incremental(bencher: Bencher) {
  function generate_compressible_data (line 642) | fn generate_compressible_data(size: usize) -> Vec<u8> {
  function generate_incompressible_data (line 653) | fn generate_incompressible_data(size: usize) -> Vec<u8> {
  function compression_high_compressibility (line 664) | fn compression_high_compressibility(bencher: Bencher) {
  function compression_low_compressibility (line 680) | fn compression_low_compressibility(bencher: Bencher) {
  function decompression_high_ratio (line 696) | fn decompression_high_ratio(bencher: Bencher) {
  function decompression_low_ratio (line 718) | fn decompression_low_ratio(bencher: Bencher) {
  function lru_hotcold_access_pattern (line 744) | fn lru_hotcold_access_pattern(bencher: Bencher) {
  function lru_sequential_scan_pattern (line 776) | fn lru_sequential_scan_pattern(bencher: Bencher) {
  function lru_realistic_eviction_pressure (line 799) | fn lru_realistic_eviction_pressure(bencher: Bencher) {
  function generate_win_path (line 824) | fn generate_win_path(depth: usize) -> Vec<u8> {
  function generate_preprocessor_output_with_paths (line 834) | fn generate_preprocessor_output_with_paths(num_includes: usize, basedir:...
  function normalize_win_path_typical (line 849) | fn normalize_win_path_typical(bencher: Bencher) {
  function strip_basedirs_typical (line 857) | fn strip_basedirs_typical(bencher: Bencher) {
  function strip_basedirs_multiple (line 871) | fn strip_basedirs_multiple(bencher: Bencher) {
  function main (line 888) | fn main() {

FILE: src/bin/sccache-dist/build.rs
  type CommandExt (line 33) | trait CommandExt {
    method check_stdout_trim (line 34) | fn check_stdout_trim(&mut self) -> Result<String>;
    method check_piped (line 35) | fn check_piped(&mut self, pipe: &mut dyn FnMut(&mut ChildStdin) -> Res...
    method check_run (line 36) | fn check_run(&mut self) -> Result<()>;
    method check_stdout_trim (line 40) | fn check_stdout_trim(&mut self) -> Result<String> {
    method check_piped (line 48) | fn check_piped(&mut self, pipe: &mut dyn FnMut(&mut ChildStdin) -> Res...
    method check_run (line 63) | fn check_run(&mut self) -> Result<()> {
  function check_output (line 69) | fn check_output(output: &Output) -> Result<()> {
  function join_suffix (line 81) | fn join_suffix<P: AsRef<Path>>(path: &Path, suffix: P) -> PathBuf {
  type OverlaySpec (line 91) | struct OverlaySpec {
  type DeflatedToolchain (line 97) | struct DeflatedToolchain {
  type OverlayBuilder (line 103) | pub struct OverlayBuilder {
    method new (line 110) | pub fn new(bubblewrap: PathBuf, dir: PathBuf) -> Result<Self> {
    method cleanup (line 164) | fn cleanup(&self) -> Result<()> {
    method prepare_overlay_dirs (line 171) | fn prepare_overlay_dirs(
    method perform_build (line 257) | fn perform_build(
    method finish_overlay (line 424) | fn finish_overlay(&self, _tc: &Toolchain, overlay: OverlaySpec) {
  method run_build (line 442) | fn run_build(
  constant BASE_DOCKER_IMAGE (line 463) | const BASE_DOCKER_IMAGE: &str = "aidanhs/busybox";
  constant DOCKER_SHELL_INIT (line 467) | const DOCKER_SHELL_INIT: &str = "while true; do /busybox sleep 365d && /...
  function docker_diff (line 470) | fn docker_diff(cid: &str) -> Result<String> {
  function docker_rm (line 478) | fn docker_rm(cid: &str) -> Result<()> {
  type DockerBuilder (line 485) | pub struct DockerBuilder {
    method new (line 494) | pub fn new() -> Result<Self> {
    method cleanup (line 507) | fn cleanup(&self) -> Result<()> {
    method get_container (line 577) | fn get_container(&self, tc: &Toolchain, tccache: &Mutex<TcCache>) -> R...
    method clean_container (line 604) | fn clean_container(&self, cid: &str) -> Result<()> {
    method finish_container (line 669) | fn finish_container(&self, tc: &Toolchain, cid: String) {
    method make_image (line 698) | fn make_image(tc: &Toolchain, tccache: &Mutex<TcCache>) -> Result<Stri...
    method start_container (line 741) | fn start_container(image: &str) -> Result<String> {
    method perform_build (line 756) | fn perform_build(
  method run_build (line 855) | fn run_build(

FILE: src/bin/sccache-dist/build_freebsd.rs
  type CommandExt (line 30) | trait CommandExt {
    method check_stdout_trim (line 31) | fn check_stdout_trim(&mut self) -> Result<String>;
    method check_piped (line 32) | fn check_piped(&mut self, pipe: &mut dyn FnMut(&mut ChildStdin) -> Res...
    method check_run (line 33) | fn check_run(&mut self) -> Result<()>;
    method check_stdout_trim (line 37) | fn check_stdout_trim(&mut self) -> Result<String> {
    method check_piped (line 45) | fn check_piped(&mut self, pipe: &mut dyn FnMut(&mut ChildStdin) -> Res...
    method check_run (line 60) | fn check_run(&mut self) -> Result<()> {
  function check_output (line 66) | fn check_output(output: &Output) -> Result<()> {
  function pot_rm (line 79) | fn pot_rm(cid: &str, pot_cmd: &PathBuf) -> Result<()> {
  type PotBuilder (line 87) | pub struct PotBuilder {
    method new (line 102) | pub fn new(
    method cleanup (line 125) | fn cleanup(&self) -> Result<()> {
    method get_container (line 149) | fn get_container(&self, tc: &Toolchain, tccache: &Mutex<TcCache>) -> R...
    method clean_container (line 183) | fn clean_container(cid: &str) -> Result<()> {
    method finish_container (line 203) | fn finish_container(
    method make_image (line 235) | fn make_image(
    method start_container (line 280) | fn start_container(
    method perform_build (line 305) | fn perform_build(
  method run_build (line 402) | fn run_build(

FILE: src/bin/sccache-dist/cmdline/mod.rs
  type Command (line 23) | pub enum Command {
  type AuthSubcommand (line 30) | pub enum AuthSubcommand {

FILE: src/bin/sccache-dist/cmdline/parse.rs
  type TokenLength (line 26) | struct TokenLength(usize);
    method as_bytes (line 29) | fn as_bytes(&self) -> usize {
    method from_bits (line 33) | fn from_bits(bits: &str) -> anyhow::Result<Self> {
    method fmt (line 51) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LogLevel (line 57) | enum LogLevel {
  type Err (line 66) | type Err = anyhow::Error;
  method from_str (line 68) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function from (line 83) | fn from(log_level: LogLevel) -> Self {
  function flag_infer_long (line 94) | fn flag_infer_long(name: &'static str) -> Arg {
  function get_clap_command (line 98) | fn get_clap_command() -> ClapCommand {
  function check_init_syslog (line 170) | fn check_init_syslog(name: &str, log_level: LogLevel) {
  function try_parse_from (line 176) | pub fn try_parse_from(
  constant EXE (line 271) | const EXE: &str = "sccache-dist";
  function auth_generate_shared_tokens_bits (line 273) | fn auth_generate_shared_tokens_bits(bit_val: &'static str) -> Vec<&'stat...
  function auth_generate_jwt_hs256_server_token (line 277) | fn auth_generate_jwt_hs256_server_token(subcommand_args: &[&'static str]...
  function debug_assert (line 284) | fn debug_assert() {
  function missing_required_subcommands_fails (line 289) | fn missing_required_subcommands_fails() {
  function invalid_token_bits_fails (line 298) | fn invalid_token_bits_fails() {
  function auth_generate_server_token_needs_key_source (line 308) | fn auth_generate_server_token_needs_key_source() {
  function assert_args_parse_to_auth (line 321) | fn assert_args_parse_to_auth(args: Vec<&'static str>, ideal_auth: AuthSu...
  function auth_generate_jwt_hs256_key_good (line 329) | fn auth_generate_jwt_hs256_key_good() {
  function auth_generate_jwt_hs256_server_token_good (line 336) | fn auth_generate_jwt_hs256_server_token_good() {
  function auth_generate_shared_token_good (line 353) | fn auth_generate_shared_token_good() {

FILE: src/bin/sccache-dist/main.rs
  constant INSECURE_DIST_SERVER_TOKEN (line 36) | pub const INSECURE_DIST_SERVER_TOKEN: &str = "dangerously_insecure_server";
  function main (line 42) | fn main() {
  function main (line 51) | fn main() {
  function create_server_token (line 95) | fn create_server_token(server_id: ServerId, auth_token: &str) -> String {
  function check_server_token (line 98) | fn check_server_token(server_token: &str, auth_token: &str) -> Option<Se...
  type ServerJwt (line 109) | struct ServerJwt {
  function create_jwt_server_token (line 113) | fn create_jwt_server_token(
  function dangerous_insecure_extract_jwt_server_token (line 121) | fn dangerous_insecure_extract_jwt_server_token(server_token: &str) -> Re...
  function check_jwt_server_token (line 134) | fn check_jwt_server_token(
  function run (line 145) | fn run(command: Command) -> Result<i32> {
  function init_logging (line 313) | fn init_logging() {
  constant MAX_PER_CORE_LOAD (line 330) | const MAX_PER_CORE_LOAD: f64 = 2f64;
  constant SERVER_REMEMBER_ERROR_TIMEOUT (line 331) | const SERVER_REMEMBER_ERROR_TIMEOUT: Duration = Duration::from_secs(300);
  constant UNCLAIMED_PENDING_TIMEOUT (line 332) | const UNCLAIMED_PENDING_TIMEOUT: Duration = Duration::from_secs(300);
  constant UNCLAIMED_READY_TIMEOUT (line 333) | const UNCLAIMED_READY_TIMEOUT: Duration = Duration::from_secs(60);
  type JobDetail (line 336) | struct JobDetail {
  type Scheduler (line 343) | pub struct Scheduler {
    method new (line 365) | pub fn new() -> Self {
    method prune_servers (line 373) | fn prune_servers(
  type ServerDetails (line 352) | struct ServerDetails {
  method default (line 415) | fn default() -> Self {
  function load_weight (line 420) | fn load_weight(job_count: usize, core_count: usize) -> f64 {
  method handle_alloc_job (line 435) | fn handle_alloc_job(
  method handle_heartbeat_server (line 574) | fn handle_heartbeat_server(
  method handle_update_job_state (line 683) | fn handle_update_job_state(
  method handle_status (line 736) | fn handle_status(&self) -> Result<SchedulerStatusResult> {
  type Server (line 751) | pub struct Server {
    method new (line 758) | pub fn new(
  method handle_assign_job (line 774) | fn handle_assign_job(&self, job_id: JobId, tc: Toolchain) -> Result<Assi...
  method handle_submit_toolchain (line 794) | fn handle_submit_toolchain(
  method handle_run_job (line 821) | fn handle_run_job(

FILE: src/bin/sccache-dist/token_check.rs
  type Jwks (line 13) | pub struct Jwks {
  type Jwk (line 18) | pub struct Jwk {
    method to_der_pkcs1 (line 27) | pub fn to_der_pkcs1(&self) -> Result<Vec<u8>> {
  type EqCheck (line 53) | pub struct EqCheck {
    method new (line 71) | pub fn new(s: String) -> Self {
  method check (line 58) | fn check(&self, token: &str) -> StdResult<(), ClientVisibleMsg> {
  type ProxyTokenCheck (line 78) | pub struct ProxyTokenCheck {
    method new (line 99) | pub fn new(url: String, cache_secs: Option<u64>) -> Self {
    method check_token_with_forwarding (line 109) | fn check_token_with_forwarding(&self, token: &str) -> Result<()> {
  method check (line 85) | fn check(&self, token: &str) -> StdResult<(), ClientVisibleMsg> {
  type ValidJWTCheck (line 143) | pub struct ValidJWTCheck {
    method new (line 164) | pub fn new(audience: String, issuer: String, jwks_url: &str) -> Result...
    method check_jwt_validity (line 183) | fn check_jwt_validity(&self, token: &str) -> Result<()> {
  method check (line 150) | fn check(&self, token: &str) -> StdResult<(), ClientVisibleMsg> {

FILE: src/cache/azure.rs
  type AzureBlobCache (line 25) | pub struct AzureBlobCache;
    method build (line 28) | pub fn build(connection_string: &str, container: &str, key_prefix: &st...

FILE: src/cache/cache.rs
  type Storage (line 60) | pub trait Storage: Send + Sync {
    method get (line 68) | async fn get(&self, key: &str) -> Result<Cache>;
    method put (line 74) | async fn put(&self, key: &str, entry: CacheWrite) -> Result<Duration>;
    method check (line 88) | async fn check(&self) -> Result<CacheMode> {
    method location (line 93) | fn location(&self) -> String;
    method cache_type_name (line 97) | fn cache_type_name(&self) -> &'static str {
    method current_size (line 102) | async fn current_size(&self) -> Result<Option<u64>>;
    method max_size (line 105) | async fn max_size(&self) -> Result<Option<u64>>;
    method preprocessor_cache_mode_config (line 108) | fn preprocessor_cache_mode_config(&self) -> PreprocessorCacheModeConfig {
    method basedirs (line 113) | fn basedirs(&self) -> &[Vec<u8>] {
    method get_preprocessor_cache_entry (line 119) | async fn get_preprocessor_cache_entry(
    method put_preprocessor_cache_entry (line 128) | async fn put_preprocessor_cache_entry(
    method get (line 185) | async fn get(&self, key: &str) -> Result<Cache> {
    method put (line 199) | async fn put(&self, key: &str, entry: CacheWrite) -> Result<Duration> {
    method check (line 209) | async fn check(&self) -> Result<CacheMode> {
    method location (line 255) | fn location(&self) -> String {
    method cache_type_name (line 265) | fn cache_type_name(&self) -> &'static str {
    method current_size (line 271) | async fn current_size(&self) -> Result<Option<u64>> {
    method max_size (line 275) | async fn max_size(&self) -> Result<Option<u64>> {
    method basedirs (line 279) | fn basedirs(&self) -> &[Vec<u8>] {
  type RemoteStorage (line 149) | pub struct RemoteStorage {
    method new (line 166) | pub fn new(operator: opendal::Operator, basedirs: Vec<Vec<u8>>) -> Self {
  function build_single_cache (line 297) | pub fn build_single_cache(
  function storage_from_config (line 492) | pub fn storage_from_config(
  function test_read_write_mode_local (line 535) | fn test_read_write_mode_local() {
  function test_operator_storage_s3_with_basedirs (line 602) | fn test_operator_storage_s3_with_basedirs() {
  function test_operator_storage_redis_with_basedirs (line 627) | fn test_operator_storage_redis_with_basedirs() {

FILE: src/cache/cache_io.rs
  type FileObjectSource (line 25) | pub struct FileObjectSource {
  type Cache (line 36) | pub enum Cache {
    method fmt (line 48) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type CacheMode (line 60) | pub enum CacheMode {
  type ReadSeek (line 68) | pub trait ReadSeek: Read + Seek + Send {}
  type CacheRead (line 73) | pub struct CacheRead {
    method from (line 91) | pub fn from<R>(reader: R) -> Result<CacheRead>
    method get_object (line 102) | pub fn get_object<T>(&mut self, name: &str, to: &mut T) -> Result<Opti...
    method get_stdout (line 116) | pub fn get_stdout(&mut self) -> Vec<u8> {
    method get_stderr (line 121) | pub fn get_stderr(&mut self) -> Vec<u8> {
    method get_bytes (line 125) | fn get_bytes(&mut self, name: &str) -> Vec<u8> {
    method extract_objects (line 131) | pub async fn extract_objects<T>(
  type DecompressionFailure (line 79) | pub struct DecompressionFailure;
    method fmt (line 82) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type CacheWrite (line 173) | pub struct CacheWrite {
    method new (line 179) | pub fn new() -> CacheWrite {
    method from_objects (line 186) | pub async fn from_objects<T>(objects: T, pool: &tokio::runtime::Handle...
    method put_object (line 218) | pub fn put_object<T>(&mut self, name: &str, from: &mut T, mode: Option...
    method put_stdout (line 242) | pub fn put_stdout(&mut self, bytes: &[u8]) -> Result<()> {
    method put_stderr (line 246) | pub fn put_stderr(&mut self, bytes: &[u8]) -> Result<()> {
    method put_bytes (line 250) | fn put_bytes(&mut self, name: &str, bytes: &[u8]) -> Result<()> {
    method finish (line 259) | pub fn finish(self) -> Result<Vec<u8>> {
  method default (line 267) | fn default() -> Self {

FILE: src/cache/cos.rs
  type COSCache (line 21) | pub struct COSCache;
    method build (line 25) | pub fn build(bucket: &str, key_prefix: &str, endpoint: Option<&str>) -...

FILE: src/cache/disk.rs
  type DiskCache (line 32) | pub struct DiskCache {
    method new (line 45) | pub fn new<T: AsRef<OsStr>>(
  function make_key_path (line 73) | fn make_key_path(key: &str) -> PathBuf {
  method get (line 79) | async fn get(&self, key: &str) -> Result<Cache> {
  method put (line 105) | async fn put(&self, key: &str, entry: CacheWrite) -> Result<Duration> {
  method check (line 133) | async fn check(&self) -> Result<CacheMode> {
  method location (line 137) | fn location(&self) -> String {
  method cache_type_name (line 141) | fn cache_type_name(&self) -> &'static str {
  method current_size (line 145) | async fn current_size(&self) -> Result<Option<u64>> {
  method max_size (line 148) | async fn max_size(&self) -> Result<Option<u64>> {
  method preprocessor_cache_mode_config (line 151) | fn preprocessor_cache_mode_config(&self) -> PreprocessorCacheModeConfig {
  method basedirs (line 154) | fn basedirs(&self) -> &[Vec<u8>] {
  method get_preprocessor_cache_entry (line 157) | async fn get_preprocessor_cache_entry(&self, key: &str) -> Result<Option...
  method put_preprocessor_cache_entry (line 167) | async fn put_preprocessor_cache_entry(
  function test_disk_cache_type_name (line 199) | fn test_disk_cache_type_name() {

FILE: src/cache/gcs.rs
  function rw_to_scope (line 29) | fn rw_to_scope(mode: CacheMode) -> &'static str {
  type GCSCache (line 37) | pub struct GCSCache;
    method build (line 41) | pub fn build(
  function fetch_taskcluster_token (line 93) | async fn fetch_taskcluster_token(url: &str, scope: &str) -> Result<Strin...
  type TaskClusterToken (line 115) | struct TaskClusterToken {

FILE: src/cache/gha.rs
  type GHACache (line 25) | pub struct GHACache;
    method build (line 28) | pub fn build(version: &str) -> Result<Operator> {

FILE: src/cache/http_client.rs
  function set_user_agent (line 5) | pub fn set_user_agent() -> HttpClient {

FILE: src/cache/lazy_disk_cache.rs
  type LazyDiskCache (line 18) | pub enum LazyDiskCache {
    method get_or_init (line 24) | pub fn get_or_init(&mut self) -> Result<&mut LruDiskCache> {
    method get (line 34) | pub fn get(&mut self) -> Option<&mut LruDiskCache> {
    method capacity (line 41) | pub fn capacity(&self) -> u64 {
    method path (line 48) | pub fn path(&self) -> &Path {

FILE: src/cache/memcached.rs
  type MemcachedCache (line 25) | pub struct MemcachedCache;
    method build (line 28) | pub fn build(

FILE: src/cache/oss.rs
  type OSSCache (line 21) | pub struct OSSCache;
    method build (line 25) | pub fn build(

FILE: src/cache/readonly.rs
  type ReadOnlyStorage (line 23) | pub struct ReadOnlyStorage(pub Arc<dyn Storage>);
  method get (line 27) | async fn get(&self, key: &str) -> Result<Cache> {
  method put (line 35) | async fn put(&self, _key: &str, _entry: CacheWrite) -> Result<Duration> {
  method check (line 42) | async fn check(&self) -> Result<CacheMode> {
  method location (line 47) | fn location(&self) -> String {
  method cache_type_name (line 52) | fn cache_type_name(&self) -> &'static str {
  method current_size (line 57) | async fn current_size(&self) -> Result<Option<u64>> {
  method max_size (line 62) | async fn max_size(&self) -> Result<Option<u64>> {
  method preprocessor_cache_mode_config (line 67) | fn preprocessor_cache_mode_config(&self) -> PreprocessorCacheModeConfig {
  method basedirs (line 72) | fn basedirs(&self) -> &[Vec<u8>] {
  method get_preprocessor_cache_entry (line 79) | async fn get_preprocessor_cache_entry(
  method put_preprocessor_cache_entry (line 89) | async fn put_preprocessor_cache_entry(
  function readonly_storage_is_readonly (line 106) | fn readonly_storage_is_readonly() {
  function readonly_storage_forwards_preprocessor_cache_mode_config (line 115) | fn readonly_storage_forwards_preprocessor_cache_mode_config() {
  function readonly_storage_forwards_basedirs (line 134) | fn readonly_storage_forwards_basedirs() {
  function readonly_storage_put_err (line 168) | fn readonly_storage_put_err() {
  function readonly_storage_forwards_cache_type_name (line 197) | fn readonly_storage_forwards_cache_type_name() {

FILE: src/cache/redis.rs
  type RedisCache (line 25) | pub struct RedisCache;
    method build_from_url (line 29) | pub fn build_from_url(url: &str, key_prefix: &str, ttl: u64) -> Result...
    method build_single (line 57) | pub fn build_single(
    method build_cluster (line 71) | pub fn build_cluster(
    method build_common (line 84) | fn build_common(

FILE: src/cache/s3.rs
  type S3Cache (line 21) | pub struct S3Cache {
    method new (line 33) | pub fn new(bucket: String, key_prefix: String, no_credentials: bool) -...
    method with_region (line 45) | pub fn with_region(mut self, region: Option<String>) -> Self {
    method with_endpoint (line 49) | pub fn with_endpoint(mut self, endpoint: Option<String>) -> Self {
    method with_use_ssl (line 53) | pub fn with_use_ssl(mut self, use_ssl: Option<bool>) -> Self {
    method with_server_side_encryption (line 57) | pub fn with_server_side_encryption(mut self, server_side_encryption: O...
    method with_enable_virtual_host_style (line 61) | pub fn with_enable_virtual_host_style(
    method build (line 68) | pub fn build(self) -> Result<Operator> {
  function endpoint_resolver (line 109) | fn endpoint_resolver(endpoint: &str, use_ssl: Option<bool>) -> Result<St...
  function test_endpoint_resolver (line 140) | fn test_endpoint_resolver() -> Result<()> {

FILE: src/cache/utils.rs
  function normalize_key (line 20) | pub(in crate::cache) fn normalize_key(key: &str) -> String {
  function get_file_mode (line 25) | pub(in crate::cache) fn get_file_mode(file: &fs::File) -> Result<Option<...
  function get_file_mode (line 32) | pub(in crate::cache) fn get_file_mode(_file: &fs::File) -> Result<Option...
  function set_file_mode (line 37) | pub(in crate::cache) fn set_file_mode(path: &Path, mode: u32) -> Result<...
  function set_file_mode (line 47) | pub(in crate::cache) fn set_file_mode(_path: &Path, _mode: u32) -> Resul...
  function test_normalize_key (line 56) | fn test_normalize_key() {

FILE: src/cache/webdav.rs
  type WebdavCache (line 21) | pub struct WebdavCache;
    method build (line 25) | pub fn build(

FILE: src/client.rs
  type ServerConnection (line 24) | pub struct ServerConnection {
    method new (line 33) | pub fn new(conn: Box<dyn Connection>) -> io::Result<ServerConnection> {
    method request (line 42) | pub fn request(&mut self, request: Request) -> Result<Response> {
    method read_one_response (line 50) | pub fn read_one_response(&mut self) -> Result<Response> {
  function connect_to_server (line 66) | pub fn connect_to_server(addr: &crate::net::SocketAddr) -> io::Result<Se...
  function connect_with_retry (line 75) | pub fn connect_with_retry(addr: &crate::net::SocketAddr) -> io::Result<S...

FILE: src/cmdline.rs
  constant ENV_VAR_INTERNAL_START_SERVER (line 23) | const ENV_VAR_INTERNAL_START_SERVER: &str = "SCCACHE_START_SERVER";
  type StatsFormat (line 26) | pub enum StatsFormat {
    method as_str (line 33) | fn as_str(&self) -> &'static str {
  type Err (line 42) | type Err = anyhow::Error;
  method from_str (line 44) | fn from_str(s: &str) -> anyhow::Result<Self> {
  type Command (line 54) | pub enum Command {
  function flag_infer_long_and_short (line 85) | fn flag_infer_long_and_short(name: &'static str) -> Arg {
  function flag_infer_long (line 89) | fn flag_infer_long(name: &'static str) -> Arg {
  function get_clap_command (line 94) | fn get_clap_command() -> clap::Command {
  function try_parse (line 187) | pub fn try_parse() -> Result<Command> {

FILE: src/commands.rs
  constant DEFAULT_PORT (line 46) | pub const DEFAULT_PORT: u16 = 4226;
  constant SERVER_STARTUP_TIMEOUT (line 49) | const SERVER_STARTUP_TIMEOUT: Duration = Duration::from_millis(10000);
  function get_addr (line 52) | fn get_addr() -> crate::net::SocketAddr {
  function ignore_all_server_io_errors (line 67) | fn ignore_all_server_io_errors() -> bool {
  function read_server_startup_status (line 74) | async fn read_server_startup_status<R: AsyncReadExt + Unpin>(
  function run_server_process (line 91) | fn run_server_process(startup_timeout: Option<Duration>) -> Result<Serve...
  function redirect_stderr (line 130) | fn redirect_stderr(f: File) {
  function redirect_stderr (line 140) | fn redirect_stderr(f: File) {
  function create_error_log (line 150) | fn create_error_log() -> Result<File> {
  function redirect_error_log (line 169) | fn redirect_error_log(f: File) -> Result<()> {
  function run_server_process (line 177) | fn run_server_process(startup_timeout: Option<Duration>) -> Result<Serve...
  function connect_or_start_server (line 303) | fn connect_or_start_server(
  function request_zero_stats (line 343) | pub fn request_zero_stats(mut conn: ServerConnection) -> Result<()> {
  function request_stats (line 356) | pub fn request_stats(mut conn: ServerConnection) -> Result<ServerInfo> {
  function request_dist_status (line 369) | pub fn request_dist_status(mut conn: ServerConnection) -> Result<DistInf...
  function request_shutdown (line 382) | pub fn request_shutdown(mut conn: ServerConnection) -> Result<ServerInfo> {
  function request_compile (line 396) | fn request_compile<W, X, Y>(
  function status_signal (line 429) | fn status_signal(status: process::ExitStatus) -> Option<i32> {
  function status_signal (line 436) | fn status_signal(_status: process::ExitStatus) -> Option<i32> {
  function handle_compile_finished (line 442) | fn handle_compile_finished(
  function handle_compile_response (line 507) | fn handle_compile_response<T>(
  function do_compile (line 592) | pub fn do_compile<T>(
  function run_command (line 616) | pub fn run_command(cmd: Command) -> Result<i32> {

FILE: src/compiler/args.rs
  type ArgParseResult (line 10) | pub type ArgParseResult<T> = StdResult<T, ArgParseError>;
  type ArgToStringResult (line 11) | pub type ArgToStringResult = StdResult<String, ArgToStringError>;
  type PathTransformerFn (line 12) | pub type PathTransformerFn<'a> = &'a mut dyn FnMut(&Path) -> Option<Stri...
  type ArgParseError (line 15) | pub enum ArgParseError {
  method fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method cause (line 33) | fn cause(&self) -> Option<&dyn Error> {
  type ArgToStringError (line 39) | pub enum ArgToStringError {
  method fmt (line 45) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 59) | fn source(&self) -> Option<&(dyn Error + 'static)> {
  type Delimiter (line 64) | pub type Delimiter = Option<u8>;
  type Argument (line 73) | pub enum Argument<T> {
  type ArgDisposition (line 87) | pub enum ArgDisposition {
  type NormalizedDisposition (line 98) | pub enum NormalizedDisposition {
  function normalize (line 106) | pub fn normalize(self, disposition: NormalizedDisposition) -> Self {
  function to_os_string (line 121) | pub fn to_os_string(&self) -> OsString {
  function flag_str (line 128) | pub fn flag_str(&self) -> Option<&'static str> {
  function get_data (line 135) | pub fn get_data(&self) -> Option<&T> {
  function iter_os_strings (line 144) | pub fn iter_os_strings(&self) -> Iter<'_, T> {
  function iter_strings (line 153) | pub fn iter_strings<F: FnMut(&Path) -> Option<String>>(
  type Iter (line 165) | pub struct Iter<'a, T> {
  type Item (line 171) | type Item = OsString;
  method next (line 173) | fn next(&mut self) -> Option<Self::Item> {
  type IterStrings (line 214) | pub struct IterStrings<'a, T, F> {
  type Item (line 222) | type Item = ArgToStringResult;
  method next (line 224) | fn next(&mut self) -> Option<Self::Item> {
  type ArgumentValue (line 319) | pub trait ArgumentValue: IntoArg + Clone + Debug {}
  type FromArg (line 323) | pub trait FromArg: Sized {
    method process (line 324) | fn process(arg: OsString) -> ArgParseResult<Self>;
    method process (line 333) | fn process(arg: OsString) -> ArgParseResult<Self> {
    method process (line 338) | fn process(arg: OsString) -> ArgParseResult<Self> {
    method process (line 343) | fn process(arg: OsString) -> ArgParseResult<Self> {
  type IntoArg (line 327) | pub trait IntoArg: Sized {
    method into_arg_os_string (line 328) | fn into_arg_os_string(self) -> OsString;
    method into_arg_string (line 329) | fn into_arg_string(self, transformer: PathTransformerFn<'_>) -> ArgToS...
    method into_arg_os_string (line 349) | fn into_arg_os_string(self) -> OsString {
    method into_arg_string (line 352) | fn into_arg_string(self, _transformer: PathTransformerFn<'_>) -> ArgTo...
    method into_arg_os_string (line 357) | fn into_arg_os_string(self) -> OsString {
    method into_arg_string (line 360) | fn into_arg_string(self, transformer: PathTransformerFn<'_>) -> ArgToS...
    method into_arg_os_string (line 365) | fn into_arg_os_string(self) -> OsString {
    method into_arg_string (line 368) | fn into_arg_string(self, _transformer: PathTransformerFn<'_>) -> ArgTo...
    method into_arg_os_string (line 373) | fn into_arg_os_string(self) -> OsString {
    method into_arg_string (line 376) | fn into_arg_string(self, _transformer: PathTransformerFn<'_>) -> ArgTo...
  function split_os_string_arg (line 381) | pub fn split_os_string_arg(val: OsString, split: &str) -> ArgParseResult...
  type ArgInfo (line 392) | pub enum ArgInfo<T> {
  function process (line 409) | fn process<F>(self, arg: &str, get_next_arg: F) -> ArgParseResult<Argume...
  function cmp (line 465) | fn cmp(&self, arg: &str) -> Ordering {
  function flag_str (line 485) | fn flag_str(&self) -> &'static str {
  function bsearch (line 496) | fn bsearch<K, T, F>(key: K, items: &[T], cmp: F) -> Option<&T>
  type SearchableArgInfo (line 524) | pub trait SearchableArgInfo<T> {
    method search (line 525) | fn search(&self, key: &str) -> Option<&ArgInfo<T>>;
    method check (line 528) | fn check(&self) -> bool;
  function search (line 534) | fn search(&self, key: &str) -> Option<&ArgInfo<T>> {
  function check (line 539) | fn check(&self) -> bool {
  function search (line 552) | fn search(&self, key: &str) -> Option<&ArgInfo<T>> {
  function check (line 568) | fn check(&self) -> bool {
  type ArgsIter (line 574) | pub struct ArgsIter<I, T, S>
  function new (line 593) | pub fn new(arguments: I, arg_info: S) -> Self {
  function with_double_dashes (line 604) | pub fn with_double_dashes(mut self) -> Self {
  type Item (line 616) | type Item = ArgParseResult<Argument<T>>;
  method next (line 618) | fn next(&mut self) -> Option<Self::Item> {
  function test_arginfo_cmp (line 735) | fn test_arginfo_cmp() {
  function test_arginfo_process (line 801) | fn test_arginfo_process() {
  function test_bsearch (line 872) | fn test_bsearch() {
  function test_multi_search (line 928) | fn test_multi_search() {
  function test_argsiter (line 949) | fn test_argsiter() {
  function test_argument_into_iter (line 1031) | fn test_argument_into_iter() {
  function test_arginfo_process_take_concat_arg_delim_doesnt_crash (line 1065) | fn test_arginfo_process_take_concat_arg_delim_doesnt_crash() {
  function test_arginfo_process_flag (line 1075) | fn test_arginfo_process_flag() {
  function test_arginfo_process_take_arg (line 1081) | fn test_arginfo_process_take_arg() {
  function test_arginfo_process_take_concat_arg (line 1089) | fn test_arginfo_process_take_concat_arg() {
  function test_arginfo_process_take_concat_arg_delim (line 1097) | fn test_arginfo_process_take_concat_arg_delim() {
  function test_arginfo_process_take_maybe_concat_arg (line 1105) | fn test_arginfo_process_take_maybe_concat_arg() {
  function test_arginfo_process_take_maybe_concat_arg_delim (line 1113) | fn test_arginfo_process_take_maybe_concat_arg_delim() {
  function test_args_iter_unsorted (line 1121) | fn test_args_iter_unsorted() {
  function test_args_iter_unsorted_2 (line 1128) | fn test_args_iter_unsorted_2() {
  function test_args_iter_no_conflict (line 1134) | fn test_args_iter_no_conflict() {

FILE: src/compiler/c.rs
  type CCompiler (line 52) | pub struct CCompiler<I>
  type CCompilerHasher (line 63) | pub struct CCompilerHasher<I>
  type ArtifactDescriptor (line 75) | pub struct ArtifactDescriptor {
  type ParsedArguments (line 85) | pub struct ParsedArguments {
    method output_pretty (line 125) | pub fn output_pretty(&self) -> Cow<'_, str> {
  type CCompilation (line 135) | struct CCompilation<I: CCompilerImpl> {
  type CCompilerKind (line 148) | pub enum CCompilerKind {
  type CCompilerImpl (line 173) | pub trait CCompilerImpl: Clone + fmt::Debug + Send + Sync + 'static {
    method kind (line 175) | fn kind(&self) -> CCompilerKind;
    method plusplus (line 177) | fn plusplus(&self) -> bool;
    method version (line 179) | fn version(&self) -> Option<String>;
    method parse_arguments (line 181) | fn parse_arguments(
    method preprocess (line 189) | async fn preprocess<T>(
    method generate_compile_commands (line 204) | fn generate_compile_commands<T>(
  function new (line 225) | pub async fn new(
  function extract_rocm_arg (line 248) | fn extract_rocm_arg(args: &ParsedArguments, flag: &str) -> Option<PathBu...
  function extract_rocm_env (line 257) | fn extract_rocm_env(env_vars: &[(OsString, OsString)], name: &str) -> Op...
  function search_hip_device_libs (line 267) | fn search_hip_device_libs(
  function kind (line 302) | fn kind(&self) -> CompilerKind {
  function get_toolchain_packager (line 306) | fn get_toolchain_packager(&self) -> Box<dyn pkg::ToolchainPackager> {
  function parse_arguments (line 312) | fn parse_arguments(
  function box_clone (line 357) | fn box_clone(&self) -> Box<dyn Compiler<T>> {
  function generate_hash_key (line 368) | async fn generate_hash_key(
  function color_mode (line 684) | fn color_mode(&self) -> ColorMode {
  function output_pretty (line 688) | fn output_pretty(&self) -> Cow<'_, str> {
  function box_clone (line 692) | fn box_clone(&self) -> Box<dyn CompilerHasher<T>> {
  function language (line 696) | fn language(&self) -> Language {
  constant PRAGMA_GCC_PCH_PREPROCESS (line 701) | const PRAGMA_GCC_PCH_PREPROCESS: &[u8] = b"pragma GCC pch_preprocess";
  constant HASH_31_COMMAND_LINE_NEWLINE (line 702) | const HASH_31_COMMAND_LINE_NEWLINE: &[u8] = b"# 31 \"<command-line>\"\n";
  constant HASH_32_COMMAND_LINE_2_NEWLINE (line 703) | const HASH_32_COMMAND_LINE_2_NEWLINE: &[u8] = b"# 32 \"<command-line>\" ...
  constant INCBIN_DIRECTIVE (line 704) | const INCBIN_DIRECTIVE: &[u8] = b".incbin";
  function process_preprocessed_file (line 708) | fn process_preprocessed_file(
  type PreprocessedLineAction (line 825) | type PreprocessedLineAction = ControlFlow<(usize, usize, bool), (usize, ...
  function process_preprocessor_line (line 828) | fn process_preprocessor_line(
  function normalize_path (line 959) | pub fn normalize_path(path: &Path) -> PathBuf {
  type PreprocessorFileMetadata (line 990) | struct PreprocessorFileMetadata {
    method from (line 998) | fn from(meta: std::fs::Metadata) -> Self {
  type PreprocessorFSAbstraction (line 1013) | trait PreprocessorFSAbstraction {
    method metadata (line 1014) | fn metadata(&self, path: impl AsRef<Path>) -> io::Result<PreprocessorF...
    method open (line 1018) | fn open(&self, path: impl AsRef<Path>) -> io::Result<Box<dyn std::io::...
    method metadata (line 1881) | fn metadata(&self, path: impl AsRef<Path>) -> io::Result<PreprocessorF...
    method open (line 1885) | fn open(&self, path: impl AsRef<Path>) -> io::Result<Box<dyn std::io::...
    method metadata (line 1897) | fn metadata(&self, path: impl AsRef<Path>) -> io::Result<PreprocessorF...
    method open (line 1908) | fn open(&self, path: impl AsRef<Path>) -> io::Result<Box<dyn std::io::...
  type StandardFsAbstraction (line 1024) | struct StandardFsAbstraction;
  function remember_include_file (line 1032) | fn remember_include_file(
  function include_is_too_new (line 1156) | fn include_is_too_new(
  constant PREPROCESSING_SKIPPED_COMPILE_POISON (line 1187) | const PREPROCESSING_SKIPPED_COMPILE_POISON: &[u8] = b"([{SCCACHE -*-* IN...
  function generate_compile_commands (line 1190) | fn generate_compile_commands(
  function into_dist_packagers (line 1210) | fn into_dist_packagers(
  function is_locally_preprocessed (line 1240) | fn is_locally_preprocessed(&self) -> bool {
  function outputs (line 1244) | fn outputs<'a>(&'a self) -> Box<dyn Iterator<Item = FileObjectSource> + ...
  type CInputsPackager (line 1259) | struct CInputsPackager {
    method write_inputs (line 1269) | fn write_inputs(self: Box<Self>, wtr: &mut dyn io::Write) -> Result<di...
  type CToolchainPackager (line 1328) | struct CToolchainPackager {
    method write_pkg (line 1336) | fn write_pkg(self: Box<Self>, f: fs::File) -> Result<()> {
  constant CACHE_VERSION (line 1449) | pub const CACHE_VERSION: &[u8] = b"12";
  type HashKeyParams (line 1489) | pub struct HashKeyParams<'a> {
  function new (line 1510) | pub fn new(
  function with_extra_hashes (line 1529) | pub fn with_extra_hashes(mut self, extra_hashes: &'a [String]) -> Self {
  function with_env_vars (line 1535) | pub fn with_env_vars(mut self, env_vars: &'a [(OsString, OsString)]) -> ...
  function with_plusplus (line 1541) | pub fn with_plusplus(mut self, plusplus: bool) -> Self {
  function with_basedirs (line 1547) | pub fn with_basedirs(mut self, basedirs: &'a [Vec<u8>]) -> Self {
  function compute (line 1560) | pub fn compute(&self) -> String {
  function test_same_content (line 1598) | fn test_same_content() {
  function test_plusplus_differs (line 1606) | fn test_plusplus_differs() {
  function test_header_differs (line 1616) | fn test_header_differs() {
  function test_plusplus_header_differs (line 1624) | fn test_plusplus_header_differs() {
  function test_hash_key_executable_contents_differs (line 1636) | fn test_hash_key_executable_contents_differs() {
  function test_hash_key_args_differs (line 1644) | fn test_hash_key_args_differs() {
  function test_hash_key_preprocessed_content_differs (line 1661) | fn test_hash_key_preprocessed_content_differs() {
  function test_hash_key_env_var_differs (line 1669) | fn test_hash_key_env_var_differs() {
  function test_extra_hash_data (line 1690) | fn test_extra_hash_data() {
  function test_hash_key_basedirs (line 1703) | fn test_hash_key_basedirs() {
  function test_language_from_file_name (line 1765) | fn test_language_from_file_name() {
  function test_language_from_file_name_none (line 1816) | fn test_language_from_file_name_none() {
  function test_process_preprocessed_file (line 1835) | fn test_process_preprocessed_file() {
  type PanicFs (line 1878) | struct PanicFs;
  type TestFs (line 1891) | struct TestFs {
  function do_single_preprocessor_line_call (line 1921) | fn do_single_preprocessor_line_call(
  function test_process_preprocessor_line_simple (line 1956) | fn test_process_preprocessor_line_simple() {
  function test_test_helpers (line 2033) | fn test_test_helpers() {
  function test_process_preprocessor_line_fs_access (line 2083) | fn test_process_preprocessor_line_fs_access() {

FILE: src/compiler/cicc.rs
  type Cicc (line 40) | pub struct Cicc {
  method kind (line 46) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 49) | fn plusplus(&self) -> bool {
  method version (line 52) | fn version(&self) -> Option<String> {
  method parse_arguments (line 55) | fn parse_arguments(
  method preprocess (line 64) | async fn preprocess<T>(
  method generate_compile_commands (line 80) | fn generate_compile_commands<T>(
  function parse_arguments (line 104) | pub fn parse_arguments<S>(
  function preprocess (line 238) | pub async fn preprocess(cwd: &Path, parsed_args: &ParsedArguments) -> Re...
  function generate_compile_commands (line 254) | pub fn generate_compile_commands(

FILE: src/compiler/clang.rs
  type Clang (line 40) | pub struct Clang {
    method is_minversion (line 50) | fn is_minversion(&self, major: u64) -> bool {
  method kind (line 84) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 87) | fn plusplus(&self) -> bool {
  method version (line 90) | fn version(&self) -> Option<String> {
  method parse_arguments (line 93) | fn parse_arguments(
  method preprocess (line 109) | async fn preprocess<T>(
  method generate_compile_commands (line 150) | fn generate_compile_commands<T>(
  function language_to_clang_arg (line 182) | pub fn language_to_clang_arg(lang: Language) -> Option<&'static str> {
  function resolve_profile_use_path (line 247) | pub(crate) fn resolve_profile_use_path(arg: &Path, cwd: &Path) -> PathBuf {
  function parse_arguments_ (line 279) | fn parse_arguments_(arguments: Vec<String>) -> CompilerArguments<ParsedA...
  function test_is_minversion (line 299) | fn test_is_minversion() {
  function test_parse_arguments_simple (line 335) | fn test_parse_arguments_simple() {
  function test_parse_arguments_values (line 354) | fn test_parse_arguments_values() {
  function test_parse_arguments_cuda (line 387) | fn test_parse_arguments_cuda() {
  function test_parse_arguments_cuda_flags (line 406) | fn test_parse_arguments_cuda_flags() {
  function test_parse_arguments_hip (line 461) | fn test_parse_arguments_hip() {
  function test_parse_arguments_hip_flags (line 480) | fn test_parse_arguments_hip_flags() {
  function test_parse_arguments_hip_paths (line 531) | fn test_parse_arguments_hip_paths() {
  function test_parse_arguments_hip_unhash_parallel_jobs (line 593) | fn test_parse_arguments_hip_unhash_parallel_jobs() {
  function test_dependent_lib (line 615) | fn test_dependent_lib() {
  function test_parse_arguments_others (line 640) | fn test_parse_arguments_others() {
  function test_gcodeview (line 654) | fn test_gcodeview() {
  function test_emit_pch (line 659) | fn test_emit_pch() {
  function test_parse_clang_short_dependency_arguments_can_be_separated (line 695) | fn test_parse_clang_short_dependency_arguments_can_be_separated() {
  function test_parse_arguments_clangmodules (line 715) | fn test_parse_arguments_clangmodules() {
  function test_parse_xclang_invalid (line 727) | fn test_parse_xclang_invalid() {
  function test_parse_xclang_load (line 756) | fn test_parse_xclang_load() {
  function test_parse_xclang_add_plugin (line 779) | fn test_parse_xclang_add_plugin() {
  function test_parse_xclang_llvm_stuff (line 797) | fn test_parse_xclang_llvm_stuff() {
  function test_parse_xclang_fexperimental_assignment_tracking (line 824) | fn test_parse_xclang_fexperimental_assignment_tracking() {
  function test_parse_xclang_plugin_arg_blink_gc_plugin (line 854) | fn test_parse_xclang_plugin_arg_blink_gc_plugin() {
  function test_parse_xclang_plugin_arg_find_bad_constructs (line 885) | fn test_parse_xclang_plugin_arg_find_bad_constructs() {
  function test_parse_xclang_verify (line 916) | fn test_parse_xclang_verify() {
  function test_parse_xclang_no_opaque_pointers (line 922) | fn test_parse_xclang_no_opaque_pointers() {
  function test_parse_xclang_fno_pch_timestamp (line 935) | fn test_parse_xclang_fno_pch_timestamp() {
  function test_parse_xclang_use_ctor_homing (line 948) | fn test_parse_xclang_use_ctor_homing() {
  function test_parse_xclang_mconstructor_aliases_all (line 954) | fn test_parse_xclang_mconstructor_aliases_all() {
  function test_parse_xclang_mrelax_all (line 967) | fn test_parse_xclang_mrelax_all() {
  function test_parse_fplugin (line 973) | fn test_parse_fplugin() {
  function test_parse_fplugin_concatenated (line 984) | fn test_parse_fplugin_concatenated() {
  function test_parse_fsanitize_blacklist (line 995) | fn test_parse_fsanitize_blacklist() {
  function test_parse_fsanitize_ignorelist (line 1011) | fn test_parse_fsanitize_ignorelist() {
  function test_parse_color_diags (line 1027) | fn test_parse_color_diags() {
  function test_parse_arguments_profile_instr_use (line 1039) | fn test_parse_arguments_profile_instr_use() {
  function test_parse_arguments_profile_use (line 1055) | fn test_parse_arguments_profile_use() {
  function test_parse_arguments_profile_use_with_directory (line 1066) | fn test_parse_arguments_profile_use_with_directory() {
  function test_parse_arguments_profile_use_with_no_argument (line 1077) | fn test_parse_arguments_profile_use_with_no_argument() {
  function test_parse_arguments_pgo_cancellation (line 1088) | fn test_parse_arguments_pgo_cancellation() {
  function test_parse_arguments_cxx20_modules_unsupported (line 1139) | fn test_parse_arguments_cxx20_modules_unsupported() {
  function test_parse_arguments_cxx20_module_precompile (line 1166) | fn test_parse_arguments_cxx20_module_precompile() {
  function test_parse_arguments_cxx20_module_fmodule_file (line 1192) | fn test_parse_arguments_cxx20_module_fmodule_file() {
  function test_parse_arguments_cxx20_module_fmodule_file_with_name (line 1204) | fn test_parse_arguments_cxx20_module_fmodule_file_with_name() {
  function test_parse_arguments_cxx20_module_fmodule_output (line 1229) | fn test_parse_arguments_cxx20_module_fmodule_output() {
  function test_parse_arguments_cxx20_module_fmodule_output_implicit_path (line 1260) | fn test_parse_arguments_cxx20_module_fmodule_output_implicit_path() {
  function test_parse_arguments_cxx20_module_fmodules_reduced_bmi (line 1284) | fn test_parse_arguments_cxx20_module_fmodules_reduced_bmi() {
  function test_parse_arguments_cxx20_module_combined_flags (line 1302) | fn test_parse_arguments_cxx20_module_combined_flags() {
  function test_compile_clang_cuda_does_not_dist_compile (line 1330) | fn test_compile_clang_cuda_does_not_dist_compile() {

FILE: src/compiler/compiler.rs
  constant CAN_DIST_DYLIBS (line 69) | pub const CAN_DIST_DYLIBS: bool = true;
  constant CAN_DIST_DYLIBS (line 77) | pub const CAN_DIST_DYLIBS: bool = false;
  type CompileCommand (line 80) | pub trait CompileCommand<T>: Send + Sync + 'static
    method execute (line 84) | async fn execute(
    method get_executable (line 90) | fn get_executable(&self) -> PathBuf;
    method get_arguments (line 91) | fn get_arguments(&self) -> Vec<OsString>;
    method get_env_vars (line 92) | fn get_env_vars(&self) -> Vec<(OsString, OsString)>;
    method get_cwd (line 93) | fn get_cwd(&self) -> PathBuf;
  type CCompileCommand (line 97) | pub struct CCompileCommand<I>
  function new (line 109) | pub fn new<T>(cmd: I) -> Box<dyn CompileCommand<T>>
  function get_executable (line 123) | fn get_executable(&self) -> PathBuf {
  function get_arguments (line 126) | fn get_arguments(&self) -> Vec<OsString> {
  function get_env_vars (line 129) | fn get_env_vars(&self) -> Vec<(OsString, OsString)> {
  function get_cwd (line 132) | fn get_cwd(&self) -> PathBuf {
  function execute (line 136) | async fn execute(
  type CompileCommandImpl (line 146) | pub trait CompileCommandImpl: Send + Sync + 'static {
    method get_executable (line 147) | fn get_executable(&self) -> PathBuf;
    method get_arguments (line 148) | fn get_arguments(&self) -> Vec<OsString>;
    method get_env_vars (line 149) | fn get_env_vars(&self) -> Vec<(OsString, OsString)>;
    method get_cwd (line 150) | fn get_cwd(&self) -> PathBuf;
    method execute (line 152) | async fn execute<T>(
    method get_executable (line 171) | fn get_executable(&self) -> PathBuf {
    method get_arguments (line 174) | fn get_arguments(&self) -> Vec<OsString> {
    method get_env_vars (line 177) | fn get_env_vars(&self) -> Vec<(OsString, OsString)> {
    method get_cwd (line 180) | fn get_cwd(&self) -> PathBuf {
    method execute (line 184) | async fn execute<T>(
  type SingleCompileCommand (line 162) | pub struct SingleCompileCommand {
  type CompilerKind (line 211) | pub enum CompilerKind {
    method lang_kind (line 383) | pub fn lang_kind(&self, lang: &Language) -> String {
    method lang_comp_kind (line 409) | pub fn lang_comp_kind(&self, lang: &Language) -> String {
  constant EXPECTED_LANGUAGE_COUNT (line 221) | const EXPECTED_LANGUAGE_COUNT: usize = 21;
  type Language (line 224) | pub enum Language {
    method from_file_name (line 250) | pub fn from_file_name(file: &Path) -> Option<Self> {
    method as_str (line 282) | pub fn as_str(self) -> &'static str {
    method needs_c_preprocessing (line 307) | pub fn needs_c_preprocessing(self) -> bool {
    method is_c_like_header (line 319) | pub fn is_c_like_header(self) -> bool {
    method to_c_preprocessed_language (line 330) | pub fn to_c_preprocessed_language(self) -> Option<Language> {
    method to_compiler_arg (line 342) | fn to_compiler_arg(self, cuda_arg: &'static str) -> Option<&'static st...
    method to_gcc_arg (line 371) | pub fn to_gcc_arg(self) -> Option<&'static str> {
    method to_clang_arg (line 377) | pub fn to_clang_arg(self) -> Option<&'static str> {
  type DistPackagers (line 428) | pub type DistPackagers = (
  type CacheLookupResult (line 434) | enum CacheLookupResult {
  type Compiler (line 440) | pub trait Compiler<T>: Send + Sync + 'static
    method kind (line 445) | fn kind(&self) -> CompilerKind;
    method get_toolchain_packager (line 448) | fn get_toolchain_packager(&self) -> Box<dyn pkg::ToolchainPackager>;
    method parse_arguments (line 450) | fn parse_arguments(
    method box_clone (line 456) | fn box_clone(&self) -> Box<dyn Compiler<T>>;
  method clone (line 460) | fn clone(&self) -> Box<dyn Compiler<T>> {
  type CompilerProxy (line 465) | pub trait CompilerProxy<T>: Send + Sync + 'static
    method resolve_proxied_executable (line 474) | fn resolve_proxied_executable(
    method box_clone (line 482) | fn box_clone(&self) -> Box<dyn CompilerProxy<T>>;
  method clone (line 486) | fn clone(&self) -> Box<dyn CompilerProxy<T>> {
  type CompilerHasher (line 494) | pub trait CompilerHasher<T>: fmt::Debug + Send + 'static
    method generate_hash_key (line 502) | async fn generate_hash_key(
    method color_mode (line 515) | fn color_mode(&self) -> ColorMode;
    method get_cached_or_compile (line 520) | async fn get_cached_or_compile(
    method output_pretty (line 816) | fn output_pretty(&self) -> Cow<'_, str>;
    method box_clone (line 818) | fn box_clone(&self) -> Box<dyn CompilerHasher<T>>;
    method language (line 820) | fn language(&self) -> Language;
  function dist_or_local_compile (line 824) | async fn dist_or_local_compile<T>(
  function dist_or_local_compile (line 849) | async fn dist_or_local_compile<T>(
  method clone (line 1077) | fn clone(&self) -> Box<dyn CompilerHasher<T>> {
  type Compilation (line 1083) | pub trait Compilation<T>: Send
    method generate_compile_commands (line 1089) | fn generate_compile_commands(
    method into_dist_packagers (line 1101) | fn into_dist_packagers(
    method is_locally_preprocessed (line 1106) | fn is_locally_preprocessed(&self) -> bool {
    method outputs (line 1114) | fn outputs<'a>(&'a self) -> Box<dyn Iterator<Item = FileObjectSource> ...
  type OutputsRewriter (line 1118) | pub trait OutputsRewriter: Send {
    method handle_outputs (line 1120) | fn handle_outputs(
    method handle_outputs (line 1132) | fn handle_outputs(
  type NoopOutputsRewriter (line 1129) | pub struct NoopOutputsRewriter;
  type HashResult (line 1143) | pub struct HashResult<T>
  type CompilerArguments (line 1157) | pub enum CompilerArguments<T> {
  type DistType (line 1186) | pub enum DistType {
  type MissType (line 1197) | pub enum MissType {
  type CacheWriteInfo (line 1211) | pub struct CacheWriteInfo {
  type CompileResult (line 1217) | pub enum CompileResult {
    method fmt (line 1251) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method eq (line 1273) | fn eq(&self, other: &CompileResult) -> bool {
  type ColorMode (line 1242) | pub enum ColorMode {
  type Cacheable (line 1292) | pub enum Cacheable {
  type CacheControl (line 1299) | pub enum CacheControl {
  function write_temp_file (line 1317) | pub async fn write_temp_file(
  function is_rustc_like (line 1336) | fn is_rustc_like<P: AsRef<Path>>(p: P) -> bool {
  function is_nvidia_cudafe (line 1347) | fn is_nvidia_cudafe<P: AsRef<Path>>(p: P) -> bool {
  function is_nvidia_cicc (line 1358) | fn is_nvidia_cicc<P: AsRef<Path>>(p: P) -> bool {
  function is_nvidia_ptxas (line 1369) | fn is_nvidia_ptxas<P: AsRef<Path>>(p: P) -> bool {
  function is_known_c_compiler (line 1382) | fn is_known_c_compiler<P: AsRef<Path>>(p: P) -> bool {
  function detect_compiler (line 1404) | async fn detect_compiler<T>(
  function resolve_rust_compiler (line 1512) | async fn resolve_rust_compiler<T>(
  function detect_c_compiler (line 1639) | async fn detect_c_compiler<T, P>(
  function get_compiler_info (line 1876) | pub async fn get_compiler_info<T>(
  function test_c_preprocessing_consistent (line 1909) | fn test_c_preprocessing_consistent() {
  function test_detect_compiler_kind_gcc (line 1973) | fn test_detect_compiler_kind_gcc() {
  function test_detect_compiler_kind_clang (line 1998) | fn test_detect_compiler_kind_clang() {
  function test_detect_compiler_must_be_clang (line 2023) | fn test_detect_compiler_must_be_clang() {
  function test_detect_compiler_vv_clang (line 2041) | fn test_detect_compiler_vv_clang() {
  function test_detect_compiler_kind_msvc (line 2062) | fn test_detect_compiler_kind_msvc() {
  function test_detect_compiler_kind_nvcc (line 2101) | fn test_detect_compiler_kind_nvcc() {
  function test_detect_compiler_kind_nvhpc (line 2119) | fn test_detect_compiler_kind_nvhpc() {
  function test_detect_compiler_kind_rustc (line 2137) | fn test_detect_compiler_kind_rustc() {
  function test_is_rustc_like (line 2155) | fn test_is_rustc_like() {
  function populate_rustc_command_mock (line 2170) | fn populate_rustc_command_mock(
  function test_detect_compiler_kind_rustc_workspace_wrapper (line 2198) | fn test_detect_compiler_kind_rustc_workspace_wrapper() {
  function test_detect_compiler_kind_diab (line 2260) | fn test_detect_compiler_kind_diab() {
  function test_detect_compiler_kind_unknown (line 2278) | fn test_detect_compiler_kind_unknown() {
  function test_detect_compiler_kind_process_fail (line 2304) | fn test_detect_compiler_kind_process_fail() {
  function test_compiler_version_affects_hash (line 2328) | fn test_compiler_version_affects_hash(preprocessor_cache_mode: bool) {
  function test_common_args_affects_hash (line 2385) | fn test_common_args_affects_hash(preprocessor_cache_mode: bool) {
  function test_preprocessed_file_works_without_preprocessor_call (line 2456) | fn test_preprocessed_file_works_without_preprocessor_call(preprocessor_c...
  function test_get_compiler_info (line 2518) | fn test_get_compiler_info() {
  function test_compiler_get_cached_or_compile (line 2539) | fn test_compiler_get_cached_or_compile(preprocessor_cache_mode: bool) {
  function test_compiler_get_cached_or_compile_dist (line 2670) | fn test_compiler_get_cached_or_compile_dist(preprocessor_cache_mode: boo...
  function test_compiler_get_cached_or_compile_cache_error (line 2801) | fn test_compiler_get_cached_or_compile_cache_error(preprocessor_cache_mo...
  function test_compiler_get_cached_or_compile_cache_get_timing (line 2890) | fn test_compiler_get_cached_or_compile_cache_get_timing(preprocessor_cac...
  function test_compiler_get_cached_or_compile_force_recache (line 2974) | fn test_compiler_get_cached_or_compile_force_recache(preprocessor_cache_...
  function test_compiler_get_cached_or_compile_preprocessor_error (line 3104) | fn test_compiler_get_cached_or_compile_preprocessor_error(preprocessor_c...
  function test_compiler_get_cached_or_compile_dist_error (line 3195) | fn test_compiler_get_cached_or_compile_dist_error(preprocessor_cache_mod...
  type ErrorPutToolchainClient (line 3326) | pub struct ErrorPutToolchainClient;
    method new (line 3329) | pub fn new() -> Arc<dyn dist::Client> {
    method do_alloc_job (line 3335) | async fn do_alloc_job(&self, _: Toolchain) -> Result<AllocJobResult> {
    method do_get_status (line 3338) | async fn do_get_status(&self) -> Result<SchedulerStatusResult> {
    method do_submit_toolchain (line 3341) | async fn do_submit_toolchain(
    method do_run_job (line 3348) | async fn do_run_job(
    method put_toolchain (line 3357) | async fn put_toolchain(
    method rewrite_includes_only (line 3365) | fn rewrite_includes_only(&self) -> bool {
    method get_custom_toolchain (line 3368) | fn get_custom_toolchain(&self, _exe: &Path) -> Option<PathBuf> {
  type ErrorAllocJobClient (line 3373) | pub struct ErrorAllocJobClient {
    method new (line 3378) | pub fn new() -> Arc<dyn dist::Client> {
    method do_alloc_job (line 3388) | async fn do_alloc_job(&self, tc: Toolchain) -> Result<AllocJobResult> {
    method do_get_status (line 3392) | async fn do_get_status(&self) -> Result<SchedulerStatusResult> {
    method do_submit_toolchain (line 3395) | async fn do_submit_toolchain(
    method do_run_job (line 3402) | async fn do_run_job(
    method put_toolchain (line 3411) | async fn put_toolchain(
    method rewrite_includes_only (line 3419) | fn rewrite_includes_only(&self) -> bool {
    method get_custom_toolchain (line 3422) | fn get_custom_toolchain(&self, _exe: &Path) -> Option<PathBuf> {
  type ErrorSubmitToolchainClient (line 3427) | pub struct ErrorSubmitToolchainClient {
    method new (line 3433) | pub fn new() -> Arc<dyn dist::Client> {
    method do_alloc_job (line 3445) | async fn do_alloc_job(&self, tc: Toolchain) -> Result<AllocJobResult> {
    method do_get_status (line 3461) | async fn do_get_status(&self) -> Result<SchedulerStatusResult> {
    method do_submit_toolchain (line 3464) | async fn do_submit_toolchain(
    method do_run_job (line 3473) | async fn do_run_job(
    method put_toolchain (line 3482) | async fn put_toolchain(
    method rewrite_includes_only (line 3490) | fn rewrite_includes_only(&self) -> bool {
    method get_custom_toolchain (line 3493) | fn get_custom_toolchain(&self, _exe: &Path) -> Option<PathBuf> {
  type ErrorRunJobClient (line 3498) | pub struct ErrorRunJobClient {
    method new (line 3504) | pub fn new() -> Arc<dyn dist::Client> {
    method do_alloc_job (line 3516) | async fn do_alloc_job(&self, tc: Toolchain) -> Result<AllocJobResult> {
    method do_get_status (line 3532) | async fn do_get_status(&self) -> Result<SchedulerStatusResult> {
    method do_submit_toolchain (line 3535) | async fn do_submit_toolchain(
    method do_run_job (line 3544) | async fn do_run_job(
    method put_toolchain (line 3555) | async fn put_toolchain(
    method rewrite_includes_only (line 3569) | fn rewrite_includes_only(&self) -> bool {
    method get_custom_toolchain (line 3572) | fn get_custom_toolchain(&self, _exe: &Path) -> Option<PathBuf> {
  type OneshotClient (line 3577) | pub struct OneshotClient {
    method new (line 3585) | pub fn new(code: i32, stdout: Vec<u8>, stderr: Vec<u8>) -> Arc<dyn dis...
    method do_alloc_job (line 3598) | async fn do_alloc_job(&self, tc: Toolchain) -> Result<AllocJobResult> {
    method do_get_status (line 3615) | async fn do_get_status(&self) -> Result<SchedulerStatusResult> {
    method do_submit_toolchain (line 3618) | async fn do_submit_toolchain(
    method do_run_job (line 3628) | async fn do_run_job(
    method put_toolchain (line 3654) | async fn put_toolchain(
    method rewrite_includes_only (line 3668) | fn rewrite_includes_only(&self) -> bool {
    method get_custom_toolchain (line 3671) | fn get_custom_toolchain(&self, _exe: &Path) -> Option<PathBuf> {

FILE: src/compiler/counted_array.rs
  function counted_array_macro (line 27) | fn counted_array_macro() {

FILE: src/compiler/cudafe.rs
  type CudaFE (line 41) | pub struct CudaFE {
  method kind (line 47) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 50) | fn plusplus(&self) -> bool {
  method version (line 53) | fn version(&self) -> Option<String> {
  method parse_arguments (line 56) | fn parse_arguments(
  method preprocess (line 65) | async fn preprocess<T>(
  method generate_compile_commands (line 81) | fn generate_compile_commands<T>(
  function generate_compile_commands (line 105) | pub fn generate_compile_commands(

FILE: src/compiler/diab.rs
  type Diab (line 40) | pub struct Diab {
  method kind (line 46) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 49) | fn plusplus(&self) -> bool {
  method version (line 52) | fn version(&self) -> Option<String> {
  method parse_arguments (line 55) | fn parse_arguments(
  method preprocess (line 65) | async fn preprocess<T>(
  method generate_compile_commands (line 82) | fn generate_compile_commands<T>(
  function parse_arguments (line 174) | pub fn parse_arguments<S>(
  function preprocess (line 322) | pub async fn preprocess<T>(
  function generate_compile_commands (line 349) | pub fn generate_compile_commands(
  type ExpandAtArgs (line 386) | pub struct ExpandAtArgs<'a> {
  function new (line 392) | pub fn new(cwd: &'a Path, args: &[OsString]) -> Self {
  type Item (line 401) | type Item = OsString;
  method next (line 403) | fn next(&mut self) -> Option<OsString> {
  function parse_arguments_ (line 471) | fn parse_arguments_(arguments: Vec<String>) -> CompilerArguments<ParsedA...
  function test_parse_arguments_simple (line 477) | fn test_parse_arguments_simple() {
  function test_parse_arguments_default_name (line 509) | fn test_parse_arguments_default_name() {
  function test_parse_arguments_extra (line 541) | fn test_parse_arguments_extra() {
  function test_parse_arguments_values (line 573) | fn test_parse_arguments_values() {
  function test_parse_arguments_preprocessor_args (line 607) | fn test_parse_arguments_preprocessor_args() {
  function test_parse_arguments_empty_args (line 657) | fn test_parse_arguments_empty_args() {
  function test_parse_arguments_not_compile (line 662) | fn test_parse_arguments_not_compile() {
  function test_parse_arguments_too_many_inputs (line 670) | fn test_parse_arguments_too_many_inputs() {
  function test_parse_arguments_link (line 678) | fn test_parse_arguments_link() {
  function test_parse_dry_run (line 686) | fn test_parse_dry_run() {
  function test_at_signs (line 699) | fn test_at_signs() {
  function test_at_signs_file_not_readable (line 709) | fn test_at_signs_file_not_readable() {
  function test_at_signs_file (line 723) | fn test_at_signs_file() {
  function test_compile_simple (line 763) | fn test_compile_simple() {

FILE: src/compiler/gcc.rs
  type Gcc (line 39) | pub struct Gcc {
  method kind (line 46) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 49) | fn plusplus(&self) -> bool {
  method version (line 52) | fn version(&self) -> Option<String> {
  method parse_arguments (line 55) | fn parse_arguments(
  method preprocess (line 65) | async fn preprocess<T>(
  method generate_compile_commands (line 99) | fn generate_compile_commands<T>(
  constant ARCH_FLAG (line 178) | const ARCH_FLAG: &str = "-arch";
  function parse_arguments (line 281) | pub fn parse_arguments<S>(
  function module_artifact_descriptor (line 772) | fn module_artifact_descriptor(
  function language_to_gcc_arg (line 799) | pub fn language_to_gcc_arg(lang: Language) -> Option<&'static str> {
  function preprocess_cmd (line 804) | fn preprocess_cmd<F, T>(
  function preprocess (line 887) | pub async fn preprocess<F, T>(
  function generate_compile_commands (line 923) | pub fn generate_compile_commands<F>(
  type ExpandIncludeFile (line 1056) | pub struct ExpandIncludeFile<'a> {
  function new (line 1062) | pub fn new(cwd: &'a Path, args: &[OsString]) -> Self {
  type Item (line 1071) | type Item = OsString;
  method next (line 1073) | fn next(&mut self) -> Option<OsString> {
  function parse_arguments_ (line 1136) | fn parse_arguments_(
  function parse_arguments_clang (line 1144) | fn parse_arguments_clang(
  function test_parse_arguments_simple (line 1159) | fn test_parse_arguments_simple() {
  function test_parse_arguments_default_name (line 1193) | fn test_parse_arguments_default_name() {
  function test_parse_arguments_default_outputdir (line 1225) | fn test_parse_arguments_default_outputdir() {
  function test_parse_arguments_objc_header_language (line 1244) | fn test_parse_arguments_objc_header_language() {
  function test_parse_arguments_split_dwarf (line 1278) | fn test_parse_arguments_split_dwarf() {
  function test_parse_arguments_linker_options (line 1323) | fn test_parse_arguments_linker_options() {
  function test_parse_arguments_coverage_outputs_gcno (line 1367) | fn test_parse_arguments_coverage_outputs_gcno() {
  function test_parse_arguments_test_coverage_outputs_gcno (line 1408) | fn test_parse_arguments_test_coverage_outputs_gcno() {
  function test_parse_arguments_profile_generate (line 1449) | fn test_parse_arguments_profile_generate() {
  function test_parse_arguments_extra (line 1483) | fn test_parse_arguments_extra() {
  function test_parse_arguments_values (line 1515) | fn test_parse_arguments_values() {
  function test_parse_arguments_preprocessor_args (line 1549) | fn test_parse_arguments_preprocessor_args() {
  function test_parse_arguments_unhashed (line 1601) | fn test_parse_arguments_unhashed() {
  function test_parse_arguments_double_dash (line 1620) | fn test_parse_arguments_double_dash() {
  function test_parse_arguments_too_hard (line 1679) | fn test_parse_arguments_too_hard() {
  function test_parse_arguments_explicit_dep_target (line 1704) | fn test_parse_arguments_explicit_dep_target() {
  function test_parse_arguments_explicit_dep_target_needed (line 1745) | fn test_parse_arguments_explicit_dep_target_needed() {
  function test_parse_arguments_explicit_mq_dep_target_needed (line 1791) | fn test_parse_arguments_explicit_mq_dep_target_needed() {
  function test_parse_arguments_diagnostics_color (line 1837) | fn test_parse_arguments_diagnostics_color() {
  function color_mode_preprocess (line 1854) | fn color_mode_preprocess() {
  function test_preprocess_cmd_rewrites_archs (line 1865) | fn test_preprocess_cmd_rewrites_archs() {
  function test_preprocess_cmd_doesnt_rewrite_single_arch (line 1902) | fn test_preprocess_cmd_doesnt_rewrite_single_arch() {
  function test_preprocess_double_dash_input (line 1937) | fn test_preprocess_double_dash_input() {
  function pedantic_default (line 1963) | fn pedantic_default() {
  function pedantic_std (line 1989) | fn pedantic_std() {
  function pedantic_gnu (line 2015) | fn pedantic_gnu() {
  function test_parse_arguments_dep_target_needed (line 2041) | fn test_parse_arguments_dep_target_needed() {
  function test_parse_arguments_dep_target_and_file_needed (line 2085) | fn test_parse_arguments_dep_target_and_file_needed() {
  function test_parse_arguments_empty_args (line 2120) | fn test_parse_arguments_empty_args() {
  function test_parse_arguments_not_compile (line 2128) | fn test_parse_arguments_not_compile() {
  function test_parse_arguments_too_many_inputs_single (line 2136) | fn test_parse_arguments_too_many_inputs_single() {
  function test_parse_arguments_too_many_inputs_multiple (line 2144) | fn test_parse_arguments_too_many_inputs_multiple() {
  function test_parse_arguments_link (line 2158) | fn test_parse_arguments_link() {
  function test_parse_arguments_pgo (line 2169) | fn test_parse_arguments_pgo() {
  function test_parse_arguments_cxx20_modules_unsupported (line 2187) | fn test_parse_arguments_cxx20_modules_unsupported() {
  function test_parse_arguments_response_file (line 2210) | fn test_parse_arguments_response_file() {
  function test_parse_index_store_path (line 2222) | fn test_parse_index_store_path() {
  function test_parse_arguments_multiarch_cache_disabled (line 2240) | fn test_parse_arguments_multiarch_cache_disabled() {
  function test_parse_arguments_multiple_arch (line 2258) | fn test_parse_arguments_multiple_arch() {
  function at_signs (line 2316) | fn at_signs() {
  function test_compile_simple (line 2360) | fn test_compile_simple() {
  function test_compile_simple_verbose_short (line 2421) | fn test_compile_simple_verbose_short() {
  function test_compile_simple_verbose_long (line 2480) | fn test_compile_simple_verbose_long() {
  function test_compile_double_dash_input (line 2539) | fn test_compile_double_dash_input() {
  function test_parse_arguments_plusplus (line 2564) | fn test_parse_arguments_plusplus() {
  function test_pch_explicit (line 2598) | fn test_pch_explicit() {
  function test_pch_implicit (line 2623) | fn test_pch_implicit() {
  function test_pch_generic (line 2648) | fn test_pch_generic() {
  function test_too_hard_for_preprocessor_cache_mode (line 2673) | fn test_too_hard_for_preprocessor_cache_mode() {

FILE: src/compiler/msvc.rs
  type Msvc (line 40) | pub struct Msvc {
  method kind (line 49) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 52) | fn plusplus(&self) -> bool {
  method version (line 55) | fn version(&self) -> Option<String> {
  method parse_arguments (line 58) | fn parse_arguments(
  method preprocess (line 68) | async fn preprocess<T>(
  method generate_compile_commands (line 96) | fn generate_compile_commands<T>(
  function from_local_codepage (line 121) | fn from_local_codepage(multi_byte_str: &[u8]) -> io::Result<String> {
  function from_local_codepage (line 127) | pub fn from_local_codepage(multi_byte_str: &[u8]) -> io::Result<String> {
  function detect_showincludes_prefix (line 170) | pub async fn detect_showincludes_prefix<T>(
  function parse_arguments (line 517) | pub fn parse_arguments(
  function normpath (line 898) | fn normpath(path: &str) -> String {
  function normpath (line 928) | fn normpath(path: &str) -> String {
  function preprocess_cmd (line 933) | pub fn preprocess_cmd<T>(
  function preprocess (line 991) | pub async fn preprocess<T>(
  function generate_compile_commands (line 1088) | fn generate_compile_commands(
  type ExpandIncludeFile (line 1214) | struct ExpandIncludeFile<'a> {
  function new (line 1227) | pub fn new(cwd: &'a Path, args: &[OsString]) -> Self {
  type Item (line 1238) | type Item = OsString;
  method next (line 1240) | fn next(&mut self) -> Option<OsString> {
  function read_text (line 1279) | fn read_text<R>(reader: &mut R) -> io::Result<String>
  type SplitMsvcResponseFileArgs (line 1323) | struct SplitMsvcResponseFileArgs<'a> {
  function from (line 1333) | fn from(file_content: &'a T) -> Self {
  function append_backslashes_to (line 1343) | fn append_backslashes_to(target: &mut String, count: &mut usize, step: u...
  type Item (line 1352) | type Item = String;
  method next (line 1354) | fn next(&mut self) -> Option<String> {
  function parse_arguments (line 1432) | fn parse_arguments(arguments: Vec<OsString>) -> CompilerArguments<Parsed...
  function parse_arguments_clang (line 1436) | fn parse_arguments_clang(arguments: Vec<OsString>) -> CompilerArguments<...
  function test_detect_showincludes_prefix (line 1441) | fn test_detect_showincludes_prefix() {
  function test_parse_arguments_simple (line 1464) | fn test_parse_arguments_simple() {
  function test_cpp_parse_arguments_collects_type_library_headers (line 1498) | fn test_cpp_parse_arguments_collects_type_library_headers() {
  function test_c_parse_arguments_does_not_collect_type_library_headers (line 1538) | fn test_c_parse_arguments_does_not_collect_type_library_headers() {
  function test_parse_compile_flag (line 1564) | fn test_parse_compile_flag() {
  function test_parse_arguments_default_name (line 1598) | fn test_parse_arguments_default_name() {
  function test_parse_arguments_double_dash (line 1630) | fn test_parse_arguments_double_dash() {
  function parse_argument_slashes (line 1689) | fn parse_argument_slashes() {
  function parse_deps_arguments (line 1721) | fn parse_deps_arguments() {
  function test_parse_arguments_clang_passthrough (line 1773) | fn test_parse_arguments_clang_passthrough() {
  function test_parse_arguments_extra (line 1833) | fn test_parse_arguments_extra() {
  function test_parse_arguments_values (line 1865) | fn test_parse_arguments_values() {
  function parse_argument_output_file_trailing_backslash (line 1910) | fn parse_argument_output_file_trailing_backslash() {
  function parse_argument_output_file_trailing_slash_multi_extension (line 1943) | fn parse_argument_output_file_trailing_slash_multi_extension() {
  function test_parse_arguments_pdb (line 1975) | fn test_parse_arguments_pdb() {
  function test_parse_arguments_pdb_no_extension (line 2014) | fn test_parse_arguments_pdb_no_extension() {
  function test_parse_arguments_pdb_with_extension (line 2054) | fn test_parse_arguments_pdb_with_extension() {
  function test_parse_arguments_pdb_custom_extension (line 2094) | fn test_parse_arguments_pdb_custom_extension() {
  function test_parse_arguments_pdb_path_with_extension (line 2134) | fn test_parse_arguments_pdb_path_with_extension() {
  function test_parse_arguments_external_include (line 2174) | fn test_parse_arguments_external_include() {
  function test_parse_arguments_external_warning_suppression_forward_slashes (line 2225) | fn test_parse_arguments_external_warning_suppression_forward_slashes() {
  function test_parse_arguments_empty_args (line 2271) | fn test_parse_arguments_empty_args() {
  function test_parse_arguments_not_compile (line 2276) | fn test_parse_arguments_not_compile() {
  function test_parse_arguments_passthrough (line 2284) | fn test_parse_arguments_passthrough() {
  function test_parse_arguments_too_many_inputs_single (line 2328) | fn test_parse_arguments_too_many_inputs_single() {
  function test_parse_arguments_too_many_inputs_multiple (line 2336) | fn test_parse_arguments_too_many_inputs_multiple() {
  function test_parse_arguments_unsupported (line 2347) | fn test_parse_arguments_unsupported() {
  function test_parse_arguments_cxx20_modules_unsupported (line 2375) | fn test_parse_arguments_cxx20_modules_unsupported() {
  function test_responsefile_missing (line 2458) | fn test_responsefile_missing() {
  function test_responsefile_absolute_path (line 2466) | fn test_responsefile_absolute_path() {
  function test_responsefile_relative_path (line 2508) | fn test_responsefile_relative_path() {
  function test_responsefile_with_quotes (line 2556) | fn test_responsefile_with_quotes() {
  function test_responsefile_multiline (line 2598) | fn test_responsefile_multiline() {
  function test_responsefile_multiline_cr (line 2640) | fn test_responsefile_multiline_cr() {
  function test_responsefile_encoding_utf16le (line 2682) | fn test_responsefile_encoding_utf16le() {
  function test_responsefile_encoding_win1252 (line 2731) | fn test_responsefile_encoding_win1252() {
  function test_parse_arguments_missing_pdb (line 2779) | fn test_parse_arguments_missing_pdb() {
  function test_parse_arguments_missing_edit_and_continue_pdb (line 2787) | fn test_parse_arguments_missing_edit_and_continue_pdb() {
  function test_preprocess_double_dash_input (line 2795) | fn test_preprocess_double_dash_input() {
  function test_compile_simple (line 2811) | fn test_compile_simple() {
  function test_compile_double_dash_input (line 2869) | fn test_compile_double_dash_input() {
  function test_compile_not_cacheable_pdb (line 2891) | fn test_compile_not_cacheable_pdb() {
  function test_parse_fsanitize_blacklist (line 2959) | fn test_parse_fsanitize_blacklist() {
  function local_oem_codepage_conversions (line 2984) | fn local_oem_codepage_conversions() {

FILE: src/compiler/nvcc.rs
  type NvccHostCompiler (line 51) | pub enum NvccHostCompiler {
  type Nvcc (line 58) | pub struct Nvcc {
  method kind (line 66) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 69) | fn plusplus(&self) -> bool {
  method version (line 72) | fn version(&self) -> Option<String> {
  method parse_arguments (line 85) | fn parse_arguments(
  method preprocess (line 155) | async fn preprocess<T>(
  method generate_compile_commands (line 277) | fn generate_compile_commands<T>(
  function generate_compile_commands (line 301) | pub fn generate_compile_commands(
  type NvccCompileCommand (line 485) | pub struct NvccCompileCommand {
  method get_executable (line 500) | fn get_executable(&self) -> PathBuf {
  method get_arguments (line 503) | fn get_arguments(&self) -> Vec<OsString> {
  method get_env_vars (line 506) | fn get_env_vars(&self) -> Vec<(OsString, OsString)> {
  method get_cwd (line 509) | fn get_cwd(&self) -> PathBuf {
  method execute (line 513) | async fn execute<T>(
  type NvccGeneratedSubcommand (line 622) | pub struct NvccGeneratedSubcommand {
  function group_nvcc_subcommands_by_compilation_stage (line 631) | async fn group_nvcc_subcommands_by_compilation_stage<T>(
  function select_nvcc_subcommands (line 915) | async fn select_nvcc_subcommands<T, F>(
  function select_valid_dryrun_lines (line 1025) | fn select_valid_dryrun_lines(re: &Regex, line: &str) -> Result<String> {
  function fold_env_vars_or_split_into_exe_and_args (line 1035) | fn fold_env_vars_or_split_into_exe_and_args(
  function remap_generated_filenames (line 1123) | fn remap_generated_filenames(
  function run_nvcc_subcommands_group (line 1227) | async fn run_nvcc_subcommands_group<T>(
  function aggregate_output (line 1336) | fn aggregate_output(lhs: process::Output, rhs: process::Output) -> proce...
  function error_to_output (line 1347) | fn error_to_output(err: Error) -> process::Output {
  function compile_result_to_output (line 1358) | fn compile_result_to_output(exe: &Path, res: protocol::CompileFinished) ...
  function status_to_code (line 1383) | fn status_to_code(res: process::ExitStatus) -> ExitStatusValue {
  function status_to_code (line 1392) | fn status_to_code(res: process::ExitStatus) -> ExitStatusValue {
  function parse_arguments_gcc (line 1487) | fn parse_arguments_gcc(arguments: Vec<String>) -> CompilerArguments<Pars...
  function parse_arguments_msvc (line 1496) | fn parse_arguments_msvc(arguments: Vec<String>) -> CompilerArguments<Par...
  function parse_arguments_nvc (line 1505) | fn parse_arguments_nvc(arguments: Vec<String>) -> CompilerArguments<Pars...
  function test_parse_arguments_simple_c (line 1541) | fn test_parse_arguments_simple_c() {
  function test_parse_arguments_simple_cu_gcc (line 1560) | fn test_parse_arguments_simple_cu_gcc() {
  function test_parse_arguments_simple_cu_nvc (line 1579) | fn test_parse_arguments_simple_cu_nvc() {
  function test_parse_arguments_simple_cu_msvc (line 1597) | fn test_parse_arguments_simple_cu_msvc() {
  function test_parse_arguments_ccbin_no_path (line 1616) | fn test_parse_arguments_ccbin_no_path() {
  function test_parse_arguments_ccbin_dir (line 1635) | fn test_parse_arguments_ccbin_dir() {
  function test_parse_threads_argument_simple_cu (line 1654) | fn test_parse_threads_argument_simple_cu() {
  function test_parse_arguments_simple_c_as_cu (line 1687) | fn test_parse_arguments_simple_c_as_cu() {
  function test_parse_arguments_dc_compile_flag (line 1706) | fn test_parse_arguments_dc_compile_flag() {
  function test_parse_arguments_fatbin_compile_flag (line 1726) | fn test_parse_arguments_fatbin_compile_flag() {
  function test_parse_arguments_cubin_compile_flag (line 1746) | fn test_parse_arguments_cubin_compile_flag() {
  function test_parse_arguments_values (line 1766) | fn test_parse_arguments_values() {
  function test_parse_md_mt_flags_cu (line 1813) | fn test_parse_md_mt_flags_cu() {
  function test_parse_generate_code_flags (line 1846) | fn test_parse_generate_code_flags() {
  function test_parse_pass_to_host_flags (line 1876) | fn test_parse_pass_to_host_flags() {
  function test_parse_no_capturing_of_xcompiler (line 1930) | fn test_parse_no_capturing_of_xcompiler() {
  function test_parse_dlink_is_not_compilation (line 1966) | fn test_parse_dlink_is_not_compilation() {
  function test_parse_cant_cache_flags (line 1992) | fn test_parse_cant_cache_flags() {

FILE: src/compiler/nvhpc.rs
  type Nvhpc (line 41) | pub struct Nvhpc {
  method kind (line 49) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 52) | fn plusplus(&self) -> bool {
  method version (line 55) | fn version(&self) -> Option<String> {
  method parse_arguments (line 58) | fn parse_arguments(
  method preprocess (line 74) | async fn preprocess<T>(
  method generate_compile_commands (line 160) | fn generate_compile_commands<T>(
  function parse_arguments_ (line 236) | fn parse_arguments_(arguments: Vec<String>) -> CompilerArguments<ParsedA...
  function test_parse_arguments_simple_c (line 255) | fn test_parse_arguments_simple_c() {
  function test_parse_arguments_simple_cxx (line 274) | fn test_parse_arguments_simple_cxx() {
  function test_parse_arguments_values (line 293) | fn test_parse_arguments_values() {
  function test_parse_md_mt_flags_cxx (line 339) | fn test_parse_md_mt_flags_cxx() {
  function test_parse_generate_code_flags (line 372) | fn test_parse_generate_code_flags() {
  function test_parse_cant_cache_flags (line 400) | fn test_parse_cant_cache_flags() {

FILE: src/compiler/preprocessor_cache.rs
  constant FORMAT_VERSION (line 44) | const FORMAT_VERSION: u8 = 0;
  constant MAX_PREPROCESSOR_CACHE_ENTRIES (line 45) | const MAX_PREPROCESSOR_CACHE_ENTRIES: usize = 100;
  constant MAX_PREPROCESSOR_CACHE_FILE_INFO_ENTRIES (line 46) | const MAX_PREPROCESSOR_CACHE_FILE_INFO_ENTRIES: usize = 10000;
  type PreprocessorCacheEntry (line 49) | pub struct PreprocessorCacheEntry {
    method new (line 61) | pub fn new() -> Self {
    method read (line 66) | pub fn read(contents: &[u8]) -> Result<Self, Error> {
    method serialize_to (line 80) | pub fn serialize_to(&self, mut buf: impl Write) -> Result<(), Error> {
    method add_result (line 92) | pub fn add_result(
    method lookup_result_digest (line 177) | pub fn lookup_result_digest(
    method result_matches (line 193) | fn result_matches(
  function preprocessor_cache_entry_hash_key (line 375) | pub fn preprocessor_cache_entry_hash_key(
  type IncludeEntry (line 442) | pub struct IncludeEntry {
  type Error (line 456) | pub enum Error {
    method from (line 463) | fn from(e: std::io::Error) -> Self {
    method from (line 469) | fn from(e: bincode::Error) -> Self {
    method fmt (line 475) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function test_find_time_macros_empty_file (line 496) | fn test_find_time_macros_empty_file() {
  function test_find_time_macros_small_file_no_match (line 503) | fn test_find_time_macros_small_file_no_match() {
  function test_find_time_macros_small_file_match (line 510) | fn test_find_time_macros_small_file_match() {
  function test_find_time_macros_small_file_match_multiple (line 532) | fn test_find_time_macros_small_file_match_multiple() {
  function test_find_time_macros_large_file_no_match (line 542) | fn test_find_time_macros_large_file_no_match() {
  function test_find_time_macros_large_file_match_no_overlap (line 552) | fn test_find_time_macros_large_file_match_no_overlap() {
  function test_find_time_macros_large_file_match_overlap (line 562) | fn test_find_time_macros_large_file_match_overlap() {
  function test_find_time_macros_large_file_match_overlap_multiple_pages (line 595) | fn test_find_time_macros_large_file_match_overlap_multiple_pages() {
  function test_find_time_macros_large_file_match_overlap_multiple_pages_tiny (line 610) | fn test_find_time_macros_large_file_match_overlap_multiple_pages_tiny() {
  function test_find_time_macros_ghost_pattern (line 629) | fn test_find_time_macros_ghost_pattern() {
  function test_preprocessor_cache_entry_hash_key_basedirs (line 643) | fn test_preprocessor_cache_entry_hash_key_basedirs() {

FILE: src/compiler/ptxas.rs
  type Ptxas (line 41) | pub struct Ptxas {
  method kind (line 47) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 50) | fn plusplus(&self) -> bool {
  method version (line 53) | fn version(&self) -> Option<String> {
  method parse_arguments (line 56) | fn parse_arguments(
  method preprocess (line 65) | async fn preprocess<T>(
  method generate_compile_commands (line 81) | fn generate_compile_commands<T>(

FILE: src/compiler/rust.rs
  constant RLIB_PREFIX (line 66) | const RLIB_PREFIX: &str = "lib";
  constant RLIB_EXTENSION (line 68) | const RLIB_EXTENSION: &str = "rlib";
  constant RMETA_EXTENSION (line 71) | const RMETA_EXTENSION: &str = "rmeta";
  constant BINS_DIR (line 75) | const BINS_DIR: &str = "bin";
  constant LIBS_DIR (line 79) | const LIBS_DIR: &str = "lib";
  constant LIBS_DIR (line 83) | const LIBS_DIR: &str = "bin";
  type Rust (line 87) | pub struct Rust {
    method new (line 405) | pub async fn new<T>(
    method kind (line 513) | fn kind(&self) -> CompilerKind {
    method get_toolchain_packager (line 517) | fn get_toolchain_packager(&self) -> Box<dyn pkg::ToolchainPackager> {
    method parse_arguments (line 533) | fn parse_arguments(
    method box_clone (line 557) | fn box_clone(&self) -> Box<dyn Compiler<T>> {
  type RustHasher (line 121) | pub struct RustHasher {
    method generate_hash_key (line 1328) | async fn generate_hash_key(
    method color_mode (line 1688) | fn color_mode(&self) -> ColorMode {
    method output_pretty (line 1692) | fn output_pretty(&self) -> Cow<'_, str> {
    method box_clone (line 1696) | fn box_clone(&self) -> Box<dyn CompilerHasher<T>> {
    method language (line 1700) | fn language(&self) -> Language {
  type RustupProxy (line 141) | pub struct RustupProxy {
    method resolve_proxied_executable (line 566) | fn resolve_proxied_executable(
    method box_clone (line 607) | fn box_clone(&self) -> Box<dyn CompilerProxy<T>> {
    method new (line 613) | pub fn new<P>(proxy_executable: P) -> Result<Self>
    method find_proxy_executable (line 621) | pub async fn find_proxy_executable<T>(
  type ParsedArguments (line 146) | pub struct ParsedArguments {
  type RustCompilation (line 196) | pub struct RustCompilation {
    method generate_compile_commands (line 1706) | fn generate_compile_commands(
    method into_dist_packagers (line 1855) | fn into_dist_packagers(
    method outputs (line 1888) | fn outputs<'a>(&'a self) -> Box<dyn Iterator<Item = FileObjectSource> ...
  type CrateTypes (line 228) | pub struct CrateTypes {
  constant CACHE_VERSION (line 238) | const CACHE_VERSION: &[u8] = b"6";
  function get_source_files_and_env_deps (line 241) | async fn get_source_files_and_env_deps<T>(
  function parse_dep_file (line 297) | fn parse_dep_file<T, U>(file: T, cwd: U) -> Result<(Vec<PathBuf>, Vec<(O...
  function parse_dep_info (line 308) | fn parse_dep_info<T>(dep_info: &str, cwd: T) -> Vec<PathBuf>
  function parse_env_dep_info (line 359) | fn parse_env_dep_info(dep_info: &str) -> Vec<(OsString, OsString)> {
  function get_compiler_outputs (line 374) | async fn get_compiler_outputs<T>(
  type ArgCrateTypes (line 749) | struct ArgCrateTypes {
  method process (line 755) | fn process(arg: OsString) -> ArgParseResult<Self> {
  method into_arg_os_string (line 777) | fn into_arg_os_string(self) -> OsString {
  method into_arg_string (line 793) | fn into_arg_string(self, _transformer: PathTransformerFn<'_>) -> ArgToSt...
  type ArgLinkLibrary (line 812) | struct ArgLinkLibrary {
  method process (line 817) | fn process(arg: OsString) -> ArgParseResult<Self> {
  method into_arg_os_string (line 827) | fn into_arg_os_string(self) -> OsString {
  method into_arg_string (line 831) | fn into_arg_string(self, _transformer: PathTransformerFn<'_>) -> ArgToSt...
  type ArgLinkPath (line 838) | struct ArgLinkPath {
  method process (line 843) | fn process(arg: OsString) -> ArgParseResult<Self> {
  method into_arg_os_string (line 856) | fn into_arg_os_string(self) -> OsString {
  method into_arg_string (line 860) | fn into_arg_string(self, transformer: PathTransformerFn<'_>) -> ArgToStr...
  type ArgCodegen (line 867) | struct ArgCodegen {
  method process (line 872) | fn process(arg: OsString) -> ArgParseResult<Self> {
  method into_arg_os_string (line 878) | fn into_arg_os_string(self) -> OsString {
  method into_arg_string (line 886) | fn into_arg_string(self, transformer: PathTransformerFn<'_>) -> ArgToStr...
  type ArgUnstable (line 897) | struct ArgUnstable {
  method process (line 902) | fn process(arg: OsString) -> ArgParseResult<Self> {
  method into_arg_os_string (line 908) | fn into_arg_os_string(self) -> OsString {
  method into_arg_string (line 916) | fn into_arg_string(self, transformer: PathTransformerFn<'_>) -> ArgToStr...
  type ArgExtern (line 927) | struct ArgExtern {
  method process (line 932) | fn process(arg: OsString) -> ArgParseResult<Self> {
  method into_arg_os_string (line 944) | fn into_arg_os_string(self) -> OsString {
  method into_arg_string (line 948) | fn into_arg_string(self, transformer: PathTransformerFn<'_>) -> ArgToStr...
  type ArgTarget (line 955) | enum ArgTarget {
  method process (line 961) | fn process(arg: OsString) -> ArgParseResult<Self> {
  method into_arg_os_string (line 987) | fn into_arg_os_string(self) -> OsString {
  method into_arg_string (line 994) | fn into_arg_string(self, transformer: PathTransformerFn<'_>) -> ArgToStr...
  function parse_arguments (line 1068) | fn parse_arguments(arguments: &[OsString], cwd: &Path) -> CompilerArgume...
  function get_path_mappings (line 1901) | fn get_path_mappings(
  type RustInputsPackager (line 1908) | struct RustInputsPackager {
    method write_inputs (line 2013) | fn write_inputs(self: Box<Self>, wtr: &mut dyn io::Write) -> Result<di...
  function can_trim_this (line 1918) | fn can_trim_this(input_path: &Path) -> bool {
  function test_can_trim_this (line 1934) | fn test_can_trim_this() {
  function maybe_add_cargo_toml (line 1953) | fn maybe_add_cargo_toml(input_path: &Path, verify: bool) -> Option<PathB...
  function test_maybe_add_cargo_toml (line 1977) | fn test_maybe_add_cargo_toml() {
  type RustToolchainPackager (line 2208) | struct RustToolchainPackager {
    method write_pkg (line 2215) | fn write_pkg(self: Box<Self>, f: fs::File) -> Result<()> {
  type RustOutputsRewriter (line 2240) | struct RustOutputsRewriter {
  method handle_outputs (line 2246) | fn handle_outputs(
  function test_rust_outputs_rewriter (line 2305) | fn test_rust_outputs_rewriter() {
  type RlibDepsDetail (line 2361) | struct RlibDepsDetail {
  type DepsSize (line 2367) | struct DepsSize;
    type Measure (line 2370) | type Measure = usize;
    method measure (line 2371) | fn measure<Q: ?Sized>(&self, _k: &Q, v: &RlibDepsDetail) -> usize
  type RlibDepReader (line 2393) | struct RlibDepReader {
    method new_with_check (line 2401) | fn new_with_check(executable: PathBuf, env_vars: &[(OsString, OsString...
    method get_rustc_version (line 2464) | fn get_rustc_version(
    method parse_rustc_version (line 2493) | fn parse_rustc_version(stdout: &[u8]) -> Result<Version> {
    method get_correct_ls_arg (line 2506) | fn get_correct_ls_arg(version: Version) -> String {
    method discover_rlib_deps (line 2514) | fn discover_rlib_deps(
  function parse_rustc_z_ls (line 2594) | fn parse_rustc_z_ls(stdout: &str) -> Result<Vec<&str>> {
  function _parse_arguments (line 2670) | fn _parse_arguments(arguments: &[String]) -> CompilerArguments<ParsedArg...
  constant TEST_RUSTC_VERSION (line 2694) | const TEST_RUSTC_VERSION: &str = r#"
  function test_parse_arguments_simple (line 2706) | fn test_parse_arguments_simple() {
  function test_parse_arguments_incremental (line 2875) | fn test_parse_arguments_incremental() {
  function test_parse_arguments_dep_info_no_extra_filename (line 2904) | fn test_parse_arguments_dep_info_no_extra_filename() {
  function test_parse_arguments_native_libs (line 2919) | fn test_parse_arguments_native_libs() {
  function test_parse_arguments_non_rlib_crate (line 2962) | fn test_parse_arguments_non_rlib_crate() {
  function test_parse_arguments_color (line 3032) | fn test_parse_arguments_color() {
  function test_parse_arguments_multiple_inputs (line 3087) | fn test_parse_arguments_multiple_inputs() {
  function test_get_compiler_outputs (line 3117) | fn test_get_compiler_outputs() {
  function test_get_compiler_outputs_fail (line 3136) | fn test_get_compiler_outputs_fail() {
  function test_parse_dep_info (line 3153) | fn test_parse_dep_info() {
  function test_parse_dep_info_with_escaped_spaces (line 3169) | fn test_parse_dep_info_with_escaped_spaces() {
  function test_parse_dep_info_cwd (line 3181) | fn test_parse_dep_info_cwd() {
  function test_parse_dep_info_abs_paths (line 3203) | fn test_parse_dep_info_abs_paths() {
  function test_parse_dep_info_cwd (line 3220) | fn test_parse_dep_info_cwd() {
  function test_parse_dep_info_abs_paths (line 3246) | fn test_parse_dep_info_abs_paths() {
  function test_parse_rustc_z_ls_pre_1_55 (line 3261) | fn test_parse_rustc_z_ls_pre_1_55() {
  function test_parse_rustc_z_ls_post_1_55 (line 3280) | fn test_parse_rustc_z_ls_post_1_55() {
  function test_rlib_dep_reader_call (line 3305) | fn test_rlib_dep_reader_call() {
  function test_rlib_dep_reader_parse_rustc_version (line 3331) | fn test_rlib_dep_reader_parse_rustc_version() {
  function test_rlib_dep_reader_get_correct_ls_arg (line 3345) | fn test_rlib_dep_reader_get_correct_ls_arg() {
  function mock_dep_info (line 3380) | fn mock_dep_info(creator: &Arc<Mutex<MockCommandCreator>>, dep_srcs: &[&...
  function mock_file_names (line 3407) | fn mock_file_names(creator: &Arc<Mutex<MockCommandCreator>>, filenames: ...
  function test_generate_hash_key (line 3421) | fn test_generate_hash_key(preprocessor_cache_mode: bool) {
  function hash_key (line 3554) | fn hash_key<F>(
  function nothing (line 3615) | fn nothing(_path: &Path) -> Result<()> {
  function test_equal_hashes_externs (line 3621) | fn test_equal_hashes_externs(preprocessor_cache_mode: bool) {
  function test_equal_hashes_link_paths (line 3678) | fn test_equal_hashes_link_paths(preprocessor_cache_mode: bool) {
  function test_equal_hashes_ignored_args (line 3728) | fn test_equal_hashes_ignored_args(preprocessor_cache_mode: bool) {
  function test_equal_hashes_ignored_check_cfg_arg (line 3783) | fn test_equal_hashes_ignored_check_cfg_arg(preprocessor_cache_mode: bool) {
  function test_equal_hashes_cfg_features (line 3831) | fn test_equal_hashes_cfg_features(preprocessor_cache_mode: bool) {
  function test_parse_unstable_profile_flag (line 3880) | fn test_parse_unstable_profile_flag() {
  function test_parse_remap_path_prefix (line 3913) | fn test_parse_remap_path_prefix() {
  function test_parse_target (line 3941) | fn test_parse_target() {

FILE: src/compiler/tasking_vx.rs
  type TaskingVX (line 42) | pub struct TaskingVX;
  method kind (line 46) | fn kind(&self) -> CCompilerKind {
  method plusplus (line 50) | fn plusplus(&self) -> bool {
  method version (line 54) | fn version(&self) -> Option<String> {
  method parse_arguments (line 58) | fn parse_arguments(
  method preprocess (line 67) | async fn preprocess<T>(
  method generate_compile_commands (line 93) | fn generate_compile_commands<T>(
  function parse_arguments (line 169) | fn parse_arguments<S>(
  function preprocess (line 300) | async fn preprocess<T>(
  function generate_compile_commands (line 362) | fn generate_compile_commands(
  function parse_arguments_ (line 412) | fn parse_arguments_(arguments: Vec<String>) -> CompilerArguments<ParsedA...
  function test_parse_arguments_simple (line 418) | fn test_parse_arguments_simple() {
  function test_parse_arguments_default_name (line 450) | fn test_parse_arguments_default_name() {
  function test_parse_arguments_extra (line 482) | fn test_parse_arguments_extra() {
  function test_parse_arguments_values (line 514) | fn test_parse_arguments_values() {
  function test_parse_arguments_preprocessor_args (line 548) | fn test_parse_arguments_preprocessor_args() {
  function test_parse_arguments_explicit_dep_target (line 591) | fn test_parse_arguments_explicit_dep_target() {
  function test_parse_arguments_implicit_dep_target (line 625) | fn test_parse_arguments_implicit_dep_target() {
  function test_parse_arguments_empty_args (line 659) | fn test_parse_arguments_empty_args() {
  function test_parse_arguments_not_compile (line 664) | fn test_parse_arguments_not_compile() {
  function test_parse_arguments_too_many_inputs (line 672) | fn test_parse_arguments_too_many_inputs() {
  function test_parse_arguments_link (line 680) | fn test_parse_arguments_link() {
  function test_parse_dry_run (line 688) | fn test_parse_dry_run() {
  function test_compile_simple (line 701) | fn test_compile_simple() {
  function test_cuda_threads_included_in_compile_command (line 755) | fn test_cuda_threads_included_in_compile_command() {

FILE: src/config.rs
  constant ORGANIZATION (line 43) | const ORGANIZATION: &str = "Mozilla";
  constant APP_NAME (line 44) | const APP_NAME: &str = "sccache";
  constant DIST_APP_NAME (line 45) | const DIST_APP_NAME: &str = "sccache-dist-client";
  constant TEN_GIGS (line 46) | const TEN_GIGS: u64 = 10 * 1024 * 1024 * 1024;
  constant INSECURE_DIST_CLIENT_TOKEN (line 48) | pub const INSECURE_DIST_CLIENT_TOKEN: &str = "dangerously_insecure_client";
  function default_disk_cache_dir (line 52) | pub fn default_disk_cache_dir() -> PathBuf {
  function default_dist_cache_dir (line 59) | pub fn default_dist_cache_dir() -> PathBuf {
  function default_disk_cache_size (line 66) | fn default_disk_cache_size() -> u64 {
  function default_toolchain_cache_size (line 69) | fn default_toolchain_cache_size() -> u64 {
  type StringOrU64Visitor (line 73) | struct StringOrU64Visitor;
    type Value (line 76) | type Value = u64;
    method expecting (line 78) | fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    method visit_str (line 82) | fn visit_str<E>(self, value: &str) -> StdResult<Self::Value, E>
    method visit_u64 (line 89) | fn visit_u64<E>(self, value: u64) -> StdResult<Self::Value, E>
    method visit_i64 (line 96) | fn visit_i64<E>(self, value: i64) -> StdResult<Self::Value, E>
  function deserialize_size_from_str (line 108) | fn deserialize_size_from_str<'de, D>(deserializer: D) -> StdResult<u64, ...
  function parse_size (line 115) | pub fn parse_size(val: &str) -> Option<u64> {
  type HTTPUrl (line 133) | pub struct HTTPUrl(reqwest::Url);
    method deserialize (line 145) | fn deserialize<D>(deserializer: D) -> StdResult<Self, D::Error>
    method from_url (line 175) | pub fn from_url(u: reqwest::Url) -> Self {
    method to_url (line 178) | pub fn to_url(&self) -> reqwest::Url {
  method serialize (line 136) | fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
  function parse_http_url (line 156) | fn parse_http_url(url: &str) -> Result<reqwest::Url> {
  type AzureCacheConfig (line 185) | pub struct AzureCacheConfig {
  type PreprocessorCacheModeConfig (line 195) | pub struct PreprocessorCacheModeConfig {
    method activated (line 234) | pub fn activated() -> Self {
  method default (line 220) | fn default() -> Self {
  type DiskCacheConfig (line 245) | pub struct DiskCacheConfig {
  method default (line 254) | fn default() -> Self {
  type CacheModeConfig (line 266) | pub enum CacheModeConfig {
  method from (line 274) | fn from(value: CacheModeConfig) -> Self {
  type GCSCacheConfig (line 284) | pub struct GCSCacheConfig {
  type GHACacheConfig (line 295) | pub struct GHACacheConfig {
  constant DEFAULT_MEMCACHED_CACHE_EXPIRATION (line 309) | const DEFAULT_MEMCACHED_CACHE_EXPIRATION: u32 = 86400;
  function default_memcached_cache_expiration (line 311) | fn default_memcached_cache_expiration() -> u32 {
  type MemcachedCacheConfig (line 317) | pub struct MemcachedCacheConfig {
  constant DEFAULT_REDIS_CACHE_TTL (line 343) | const DEFAULT_REDIS_CACHE_TTL: u64 = 0;
  constant DEFAULT_REDIS_DB (line 344) | pub const DEFAULT_REDIS_DB: u32 = 0;
  type RedisCacheConfig (line 347) | pub struct RedisCacheConfig {
  type WebdavCacheConfig (line 384) | pub struct WebdavCacheConfig {
  type S3CacheConfig (line 395) | pub struct S3CacheConfig {
  type OSSCacheConfig (line 409) | pub struct OSSCacheConfig {
  type COSCacheConfig (line 419) | pub struct COSCacheConfig {
  type CacheType (line 427) | pub enum CacheType {
  type CacheConfigs (line 441) | pub struct CacheConfigs {
    method into_fallback (line 457) | fn into_fallback(self) -> (Option<CacheType>, DiskCacheConfig) {
    method merge (line 488) | fn merge(&mut self, other: Self) {
  type DistToolchainConfig (line 538) | pub enum DistToolchainConfig {
  type DistAuth (line 551) | pub enum DistAuth {
    method deserialize (line 567) | fn deserialize<D>(deserializer: D) -> StdResult<Self, D::Error>
  method default (line 612) | fn default() -> Self {
  type DistConfig (line 622) | pub struct DistConfig {
  method default (line 636) | fn default() -> Self {
  type FileConfig (line 652) | pub struct FileConfig {
  function try_read_config_file (line 662) | pub fn try_read_config_file<T: DeserializeOwned>(path: &Path) -> Result<...
  type EnvConfig (line 693) | pub struct EnvConfig {
  function key_prefix_from_env_var (line 698) | fn key_prefix_from_env_var(env_var_name: &str) -> String {
  function number_from_env_var (line 708) | fn number_from_env_var<A: std::str::FromStr>(env_var_name: &str) -> Opti...
  function bool_from_env_var (line 720) | fn bool_from_env_var(env_var_name: &str) -> Result<Option<bool>> {
  function config_from_env (line 734) | fn config_from_env() -> Result<EnvConfig> {
  function config_file (line 1057) | fn config_file(env_var: &str, leaf: &str) -> PathBuf {
  type Config (line 1078) | pub struct Config {
    method load (line 1089) | pub fn load() -> Result<Self> {
    method from_env_and_file_configs (line 1100) | fn from_env_and_file_configs(env_conf: EnvConfig, file_conf: FileConfi...
  type CachedDistConfig (line 1184) | pub struct CachedDistConfig {
  type CachedFileConfig (line 1191) | pub struct CachedFileConfig {
  type CachedConfig (line 1196) | pub struct CachedConfig(());
    method load (line 1199) | pub fn load() -> Result<Self> {
    method reload (line 1208) | pub fn reload() -> Result<Self> {
    method with (line 1215) | pub fn with<F: FnOnce(&CachedFileConfig) -> T, T>(&self, f: F) -> T {
    method with_mut (line 1221) | pub fn with_mut<F: FnOnce(&mut CachedFileConfig)>(&self, f: F) -> Resu...
    method file_config_path (line 1232) | fn file_config_path() -> PathBuf {
    method load_file_config (line 1235) | fn load_file_config() -> Result<CachedFileConfig> {
    method save_file_config (line 1257) | fn save_file_config(c: &CachedFileConfig) -> Result<()> {
  type ClientAuth (line 1277) | pub enum ClientAuth {
  type ServerAuth (line 1298) | pub enum ServerAuth {
  type Config (line 1309) | pub struct Config {
    method load (line 1089) | pub fn load() -> Result<Self> {
    method from_env_and_file_configs (line 1100) | fn from_env_and_file_configs(env_conf: EnvConfig, file_conf: FileConfi...
  function from_path (line 1315) | pub fn from_path(conf_path: &Path) -> Result<Option<Config>> {
  constant TEN_GIGS (line 1329) | const TEN_GIGS: u64 = 10 * 1024 * 1024 * 1024;
  function default_toolchain_cache_size (line 1330) | fn default_toolchain_cache_size() -> u64 {
  constant DEFAULT_POT_CLONE_FROM (line 1334) | const DEFAULT_POT_CLONE_FROM: &str = "sccache-template";
  constant DEFAULT_POT_FS_ROOT (line 1335) | const DEFAULT_POT_FS_ROOT: &str = "/opt/pot";
  constant DEFAULT_POT_CMD (line 1336) | const DEFAULT_POT_CMD: &str = "pot";
  constant DEFAULT_POT_CLONE_ARGS (line 1337) | const DEFAULT_POT_CLONE_ARGS: &[&str] = &["-i", "lo0|127.0.0.2"];
  function default_pot_clone_from (line 1339) | fn default_pot_clone_from() -> String {
  function default_pot_fs_root (line 1343) | fn default_pot_fs_root() -> PathBuf {
  function default_pot_cmd (line 1347) | fn default_pot_cmd() -> PathBuf {
  function default_pot_clone_args (line 1351) | fn default_pot_clone_args() -> Vec<String> {
  type BuilderType (line 1361) | pub enum BuilderType {
  type SchedulerAuth (line 1385) | pub enum SchedulerAuth {
  type Config (line 1396) | pub struct Config {
    method load (line 1089) | pub fn load() -> Result<Self> {
    method from_env_and_file_configs (line 1100) | fn from_env_and_file_configs(env_conf: EnvConfig, file_conf: FileConfi...
  function from_path (line 1407) | pub fn from_path(conf_path: &Path) -> Result<Option<Config>> {
  function test_parse_size (line 1413) | fn test_parse_size() {
  function config_overrides (line 1425) | fn config_overrides() {
  function config_basedirs_overrides (line 1507) | fn config_basedirs_overrides() {
  function config_basedirs_overrides (line 1575) | fn config_basedirs_overrides() {
  function test_deserialize_basedirs (line 1657) | fn test_deserialize_basedirs() {
  function test_deserialize_basedirs_missing (line 1680) | fn test_deserialize_basedirs_missing() {
  function test_env_basedirs_single (line 1697) | fn test_env_basedirs_single() {
  function test_env_basedirs_single (line 1715) | fn test_env_basedirs_single() {
  function test_env_basedirs_multiple (line 1733) | fn test_env_basedirs_multiple() {
  function test_env_basedirs_multiple (line 1757) | fn test_env_basedirs_multiple() {
  function test_env_basedirs_with_spaces (line 1781) | fn test_env_basedirs_with_spaces() {
  function test_env_basedirs_with_spaces (line 1815) | fn test_env_basedirs_with_spaces() {
  function test_env_basedirs_empty_entries (line 1849) | fn test_env_basedirs_empty_entries() {
  function test_env_basedirs_empty_entries (line 1874) | fn test_env_basedirs_empty_entries() {
  function test_env_basedirs_not_set (line 1898) | fn test_env_basedirs_not_set() {
  function test_s3_no_credentials_conflict (line 1909) | fn test_s3_no_credentials_conflict() {
  function test_s3_no_credentials_invalid (line 1935) | fn test_s3_no_credentials_invalid() {
  function test_s3_no_credentials_valid_true (line 1957) | fn test_s3_no_credentials_valid_true() {
  function test_s3_no_credentials_valid_false (line 1986) | fn test_s3_no_credentials_valid_false() {
  function test_gcs_service_account (line 2016) | fn test_gcs_service_account() {
  function full_toml_parse (line 2048) | fn full_toml_parse() {
  function server_toml_parse (line 2228) | fn server_toml_parse() {
  function human_units_parse (line 2289) | fn human_units_parse() {
  function test_integration_config_normalizes_and_strips (line 2323) | fn test_integration_config_normalizes_and_strips() {
  function test_integration_normalized_path_with_double_slashes (line 2357) | fn test_integration_normalized_path_with_double_slashes() {
  function test_integration_windows_path_normalization (line 2386) | fn test_integration_windows_path_normalization() {
  function test_integration_cow_borrowed_when_no_match (line 2415) | fn test_integration_cow_borrowed_when_no_match() {
  function test_integration_cow_borrowed_when_empty_basedirs (line 2445) | fn test_integration_cow_borrowed_when_empty_basedirs() {
  function test_integration_multiple_basedirs_longest_match (line 2475) | fn test_integration_multiple_basedirs_longest_match() {
  function test_integration_paths_with_dots_normalized (line 2509) | fn test_integration_paths_with_dots_normalized() {
  function test_integration_windows_mixed_slashes (line 2539) | fn test_integration_windows_mixed_slashes() {
  function test_integration_env_variable_to_strip (line 2570) | fn test_integration_env_variable_to_strip() {

FILE: src/dist/cache.rs
  type CustomToolchain (line 30) | pub struct CustomToolchain {
  type ClientToolchains (line 36) | pub struct ClientToolchains {
    method new (line 58) | pub fn new(
    method get_toolchain (line 169) | pub fn get_toolchain(&self, tc: &Toolchain) -> Result<Option<fs::File>> {
    method put_toolchain (line 190) | pub fn put_toolchain(
    method get_custom_toolchain (line 224) | pub fn get_custom_toolchain(
    method weak_to_strong (line 273) | fn weak_to_strong(&self, weak_key: &str) -> Option<String> {
    method record_weak (line 280) | fn record_weak(&self, weak_key: String, key: String) -> Result<()> {
  type PanicToolchainPackager (line 299) | struct PanicToolchainPackager;
    method new (line 301) | fn new() -> Box<Self> {
    method write_pkg (line 307) | fn write_pkg(self: Box<Self>, _f: super::fs::File) -> crate::errors::R...
  function test_client_toolchains_custom (line 313) | fn test_client_toolchains_custom() {
  function test_client_toolchains_custom_multiuse_archive (line 344) | fn test_client_toolchains_custom_multiuse_archive() {
  function test_client_toolchains_nodist (line 405) | fn test_client_toolchains_nodist() {
  function test_client_toolchains_custom_nodist_conflict (line 432) | fn test_client_toolchains_custom_nodist_conflict() {
  type TcCache (line 460) | pub struct TcCache {
    method new (line 465) | pub fn new(cache_dir: &Path, cache_size: u64) -> Result<TcCache> {
    method contains_toolchain (line 472) | pub fn contains_toolchain(&self, tc: &Toolchain) -> bool {
    method insert_with (line 476) | pub fn insert_with<F: FnOnce(fs::File) -> io::Result<()>>(
    method get_file (line 492) | pub fn get_file(&mut self, tc: &Toolchain) -> LruResult<fs::File> {
    method get (line 496) | pub fn get(&mut self, tc: &Toolchain) -> LruResult<Box<dyn ReadSeek>> {
    method len (line 500) | pub fn len(&self) -> usize {
    method is_empty (line 504) | pub fn is_empty(&self) -> bool {
    method remove (line 508) | pub fn remove(&mut self, tc: &Toolchain) -> LruResult<()> {
    method insert_file (line 513) | fn insert_file(&mut self, path: &Path) -> Result<Toolchain> {
  function path_key (line 522) | fn path_key(path: &Path) -> Result<String> {
  function file_key (line 526) | fn file_key<R: Read>(rdr: R) -> Result<String> {
  function make_lru_key_path (line 530) | fn make_lru_key_path(key: &str) -> PathBuf {

FILE: src/dist/client_auth.rs
  constant VALID_PORTS (line 21) | pub const VALID_PORTS: &[u16] = &[12731, 32492, 56909];
  constant MIN_TOKEN_VALIDITY (line 23) | const MIN_TOKEN_VALIDITY: Duration = Duration::from_secs(2 * 24 * 60 * 60);
  constant MIN_TOKEN_VALIDITY_WARNING (line 24) | const MIN_TOKEN_VALIDITY_WARNING: &str = "two days";
  function query_pairs (line 26) | fn query_pairs(url: &str) -> Result<HashMap<String, String>> {
  function html_response (line 38) | fn html_response(body: &'static str) -> Response<Full<Bytes>> {
  function json_response (line 46) | fn json_response<T: Serialize>(data: &T) -> Result<Response<Full<Bytes>>> {
  constant REDIRECT_WITH_AUTH_JSON (line 56) | const REDIRECT_WITH_AUTH_JSON: &str = r##"<!doctype html>
  constant CLIENT_ID_PARAM (line 107) | const CLIENT_ID_PARAM: &str = "client_id";
  constant CODE_CHALLENGE_PARAM (line 108) | const CODE_CHALLENGE_PARAM: &str = "code_challenge";
  constant CODE_CHALLENGE_METHOD_PARAM (line 109) | const CODE_CHALLENGE_METHOD_PARAM: &str = "code_challenge_method";
  constant CODE_CHALLENGE_METHOD_VALUE (line 110) | const CODE_CHALLENGE_METHOD_VALUE: &str = "S256";
  constant REDIRECT_PARAM (line 111) | const REDIRECT_PARAM: &str = "redirect_uri";
  constant RESPONSE_TYPE_PARAM (line 112) | const RESPONSE_TYPE_PARAM: &str = "response_type";
  constant RESPONSE_TYPE_PARAM_VALUE (line 113) | const RESPONSE_TYPE_PARAM_VALUE: &str = "code";
  constant STATE_PARAM (line 114) | const STATE_PARAM: &str = "state";
  constant CODE_RESULT_PARAM (line 116) | const CODE_RESULT_PARAM: &str = "code";
  constant STATE_RESULT_PARAM (line 117) | const STATE_RESULT_PARAM: &str = "state";
  type TokenRequest (line 121) | struct TokenRequest<'a> {
  constant GRANT_TYPE_PARAM_VALUE (line 128) | const GRANT_TYPE_PARAM_VALUE: &str = "authorization_code";
  type TokenResponse (line 131) | struct TokenResponse {
  constant TOKEN_TYPE_RESULT_PARAM_VALUE (line 136) | const TOKEN_TYPE_RESULT_PARAM_VALUE: &str = "bearer";
  constant NUM_CODE_VERIFIER_BYTES (line 138) | const NUM_CODE_VERIFIER_BYTES: usize = 256 / 8;
  type State (line 140) | pub struct State {
  function generate_verifier_and_challenge (line 149) | pub fn generate_verifier_and_challenge() -> Result<(String, String)> {
  function finish_url (line 159) | pub fn finish_url(
  function handle_code_response (line 175) | fn handle_code_response(params: HashMap<String, String>) -> Result<(Stri...
  function handle_token_response (line 185) | fn handle_token_response(res: TokenResponse) -> Result<(String, Instant)> {
  constant SUCCESS_AFTER_REDIRECT (line 198) | const SUCCESS_AFTER_REDIRECT: &str = r##"<!doctype html>
  function serve (line 205) | pub fn serve(req: Request<hyper::body::Incoming>) -> Result<Response<Ful...
  function code_to_token (line 235) | pub fn code_to_token(
  constant CLIENT_ID_PARAM (line 295) | const CLIENT_ID_PARAM: &str = "client_id";
  constant REDIRECT_PARAM (line 296) | const REDIRECT_PARAM: &str = "redirect_uri";
  constant RESPONSE_TYPE_PARAM (line 297) | const RESPONSE_TYPE_PARAM: &str = "response_type";
  constant RESPONSE_TYPE_PARAM_VALUE (line 298) | const RESPONSE_TYPE_PARAM_VALUE: &str = "token";
  constant STATE_PARAM (line 299) | const STATE_PARAM: &str = "state";
  constant TOKEN_RESULT_PARAM (line 301) | const TOKEN_RESULT_PARAM: &str = "access_token";
  constant TOKEN_TYPE_RESULT_PARAM (line 302) | const TOKEN_TYPE_RESULT_PARAM: &str = "token_type";
  constant TOKEN_TYPE_RESULT_PARAM_VALUE (line 303) | const TOKEN_TYPE_RESULT_PARAM_VALUE: &str = "bearer";
  constant EXPIRES_IN_RESULT_PARAM (line 304) | const EXPIRES_IN_RESULT_PARAM: &str = "expires_in";
  constant STATE_RESULT_PARAM (line 305) | const STATE_RESULT_PARAM: &str = "state";
  type State (line 307) | pub struct State {
  function finish_url (line 316) | pub fn finish_url(client_id: &str, url: &mut Url, redirect_uri: &str, st...
  function handle_response (line 324) | fn handle_response(params: HashMap<String, String>) -> Result<(String, I...
  constant SAVE_AUTH_AFTER_REDIRECT (line 353) | const SAVE_AUTH_AFTER_REDIRECT: &str = r##"<!doctype html>
  function serve (line 382) | pub fn serve(req: Request<hyper::body::Incoming>) -> Result<Response<Ful...
  type HyperBuilderWrap (line 427) | struct HyperBuilderWrap {
    method try_bind (line 432) | pub async fn try_bind(addr: SocketAddr) -> io::Result<HyperBuilderWrap> {
    method serve (line 441) | async fn serve<F>(&mut self, sfn: F) -> io::Result<()>
    method local_addr (line 469) | pub fn local_addr(&self) -> SocketAddr {
  function error_code_response (line 475) | fn error_code_response<E>(uri: hyper::Uri, e: E) -> hyper::Result<Respon...
  function try_bind (line 495) | async fn try_bind() -> Result<HyperBuilderWrap> {
  function get_token_oauth2_code_grant_pkce (line 535) | pub fn get_token_oauth2_code_grant_pkce(
  function get_token_oauth2_implicit (line 593) | pub fn get_token_oauth2_implicit(client_id: &str, mut auth_url: Url) -> ...

FILE: src/dist/http.rs
  type ReqwestRequestBuilderExt (line 34) | pub trait ReqwestRequestBuilderExt: Sized {
    method bincode (line 35) | fn bincode<T: serde::Serialize + ?Sized>(self, bincode: &T) -> Result<...
    method bytes (line 36) | fn bytes(self, bytes: Vec<u8>) -> Self;
    method bincode (line 39) | fn bincode<T: serde::Serialize + ?Sized>(self, bincode: &T) -> Result<...
    method bytes (line 44) | fn bytes(self, bytes: Vec<u8>) -> Self {
    method bincode (line 54) | fn bincode<T: serde::Serialize + ?Sized>(self, bincode: &T) -> Result<...
    method bytes (line 59) | fn bytes(self, bytes: Vec<u8>) -> Self {
  function bincode_req_fut (line 70) | pub async fn bincode_req_fut<T: serde::de::DeserializeOwned + 'static>(
  type AllocJobHttpResponse (line 97) | pub enum AllocJobHttpResponse {
    method from_alloc_job_result (line 109) | pub fn from_alloc_job_result(
  type ServerCertificateHttpResponse (line 140) | pub struct ServerCertificateHttpResponse {
  type HeartbeatServerHttpRequest (line 148) | pub struct HeartbeatServerHttpRequest {
    method fmt (line 159) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type RunJobHttpRequest (line 180) | pub struct RunJobHttpRequest {
  function scheduler_alloc_job (line 189) | pub fn scheduler_alloc_job(scheduler_url: &reqwest::Url) -> reqwest::Url {
  function scheduler_server_certificate (line 194) | pub fn scheduler_server_certificate(
  function scheduler_heartbeat_server (line 205) | pub fn scheduler_heartbeat_server(scheduler_url: &reqwest::Url) -> reqwe...
  function scheduler_job_state (line 210) | pub fn scheduler_job_state(scheduler_url: &reqwest::Url, job_id: JobId) ...
  function scheduler_status (line 215) | pub fn scheduler_status(scheduler_url: &reqwest::Url) -> reqwest::Url {
  function server_assign_job (line 221) | pub fn server_assign_job(server_id: ServerId, job_id: JobId) -> reqwest:...
  function server_submit_toolchain (line 229) | pub fn server_submit_toolchain(server_id: ServerId, job_id: JobId) -> re...
  function server_run_job (line 237) | pub fn server_run_job(server_id: ServerId, job_id: JobId) -> reqwest::Url {
  constant HEARTBEAT_INTERVAL (line 277) | const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(30);
  constant HEARTBEAT_ERROR_INTERVAL (line 278) | const HEARTBEAT_ERROR_INTERVAL: Duration = Duration::from_secs(10);
  constant HEARTBEAT_TIMEOUT (line 279) | pub const HEARTBEAT_TIMEOUT: Duration = Duration::from_secs(90);
  function bincode_req (line 281) | pub fn bincode_req<T: serde::de::DeserializeOwned + 'static>(
  function create_https_cert_and_privkey (line 303) | fn create_https_cert_and_privkey(addr: SocketAddr) -> Result<(Vec<u8>, V...
  type ClientVisibleMsg (line 385) | pub struct ClientVisibleMsg(String);
    method from_nonsensitive (line 387) | pub fn from_nonsensitive(s: String) -> Self {
  type ClientAuthCheck (line 392) | pub trait ClientAuthCheck: Send + Sync {
    method check (line 393) | fn check(&self, token: &str) -> StdResult<(), ClientVisibleMsg>;
  type ServerAuthCheck (line 395) | pub type ServerAuthCheck = Box<dyn Fn(&str) -> Option<ServerId> + Send +...
  constant JWT_KEY_LENGTH (line 397) | const JWT_KEY_LENGTH: usize = 256 / 8;
  type RouilleBincodeError (line 410) | pub enum RouilleBincodeError {
    method from (line 416) | fn from(err: bincode::Error) -> RouilleBincodeError {
    method source (line 421) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 429) | fn fmt(
  function bincode_input (line 448) | fn bincode_input<O>(request: &rouille::Request) -> std::result::Result<O...
  type ErrJson (line 469) | pub struct ErrJson {
    method from_err (line 475) | fn from_err<E: ?Sized + std::error::Error>(err: &E) -> ErrJson {
    method into_data (line 483) | fn into_data(self) -> String {
  function make_401_with_body (line 521) | fn make_401_with_body(short_err: &str, body: ClientVisibleMsg) -> rouill...
  function make_401 (line 532) | fn make_401(short_err: &str) -> rouille::Response {
  function bearer_http_auth (line 535) | fn bearer_http_auth(request: &rouille::Request) -> Option<&str> {
  function bincode_response (line 549) | pub fn bincode_response<T>(content: &T) -> rouille::Response
  function prepare_response (line 569) | pub fn prepare_response<T>(request: &rouille::Request, content: &T) -> r...
  type JobJwt (line 599) | struct JobJwt {
  type JWTJobAuthorizer (line 605) | struct JWTJobAuthorizer {
    method new (line 609) | fn new(server_key: Vec<u8>) -> Box<Self> {
    method generate_token (line 614) | fn generate_token(&self, job_id: JobId) -> Result<String> {
    method verify_token (line 620) | fn verify_token(&self, job_id: JobId, token: &str) -> Result<()> {
  function test_job_token_verification (line 638) | fn test_job_token_verification() {
  type Scheduler (line 661) | pub struct Scheduler<S> {
  function new (line 671) | pub fn new(
  function start (line 685) | pub fn start(self) -> Result<Infallible> {
  type SchedulerRequester (line 864) | struct SchedulerRequester {
    method do_assign_job (line 869) | fn do_assign_job(
  type Server (line 883) | pub struct Server<S> {
  function new (line 899) | pub fn new(
  function start (line 926) | pub fn start(self) -> Result<Infallible> {
  type ServerRequester (line 1043) | struct ServerRequester {
    method do_update_job_state (line 1050) | fn do_update_job_state(
  constant REQUEST_TIMEOUT_SECS (line 1096) | const REQUEST_TIMEOUT_SECS: u64 = 1200;
  constant CONNECT_TIMEOUT_SECS (line 1097) | const CONNECT_TIMEOUT_SECS: u64 = 5;
  type Client (line 1099) | pub struct Client {
    method new (line 1111) | pub fn new(
    method update_certs (line 1144) | fn update_certs(
    method do_alloc_job (line 1178) | async fn do_alloc_job(&self, tc: Toolchain) -> Result<AllocJobResult> {
    method do_get_status (line 1238) | async fn do_get_status(&self) -> Result<SchedulerStatusResult> {
    method do_submit_toolchain (line 1245) | async fn do_submit_toolchain(
    method do_run_job (line 1265) | async fn do_run_job(
    method put_toolchain (line 1311) | async fn put_toolchain(
    method rewrite_includes_only (line 1328) | fn rewrite_includes_only(&self) -> bool {
    method get_custom_toolchain (line 1331) | fn get_custom_toolchain(&self, exe: &Path) -> Option<PathBuf> {

FILE: src/dist/mod.rs
  type ToolchainPackager (line 52) | pub trait ToolchainPackager {}
  type InputsPackager (line 53) | pub trait InputsPackager {}
  function take_prefix (line 62) | fn take_prefix<'a>(components: &'a mut Components<'_>) -> Option<PrefixC...
  function transform_prefix_component (line 75) | fn transform_prefix_component(pc: PrefixComponent<'_>) -> Option<String> {
  type PathTransformer (line 96) | pub struct PathTransformer {
    method new (line 101) | pub fn new() -> Self {
    method as_dist_abs (line 106) | pub fn as_dist_abs(&mut self, p: &Path) -> Option<String> {
    method as_dist (line 112) | pub fn as_dist(&mut self, p: &Path) -> Option<String> {
    method disk_mappings (line 157) | pub fn disk_mappings(&self) -> impl Iterator<Item = (PathBuf, String)> {
    method to_local (line 185) | pub fn to_local(&self, p: &str) -> Option<PathBuf> {
    method new (line 276) | pub fn new() -> Self {
    method as_dist_abs (line 279) | pub fn as_dist_abs(&mut self, p: &Path) -> Option<String> {
    method as_dist (line 285) | pub fn as_dist(&mut self, p: &Path) -> Option<String> {
    method disk_mappings (line 288) | pub fn disk_mappings(&self) -> impl Iterator<Item = (PathBuf, String)> {
    method to_local (line 291) | pub fn to_local(&self, p: &str) -> Option<PathBuf> {
  function test_basic (line 191) | fn test_basic() {
  function test_relative_paths (line 223) | fn test_relative_paths() {
  function test_verbatim_disks (line 231) | fn test_verbatim_disks() {
  function test_slash_directions (line 258) | fn test_slash_directions() {
  type PathTransformer (line 273) | pub struct PathTransformer;
    method new (line 101) | pub fn new() -> Self {
    method as_dist_abs (line 106) | pub fn as_dist_abs(&mut self, p: &Path) -> Option<String> {
    method as_dist (line 112) | pub fn as_dist(&mut self, p: &Path) -> Option<String> {
    method disk_mappings (line 157) | pub fn disk_mappings(&self) -> impl Iterator<Item = (PathBuf, String)> {
    method to_local (line 185) | pub fn to_local(&self, p: &str) -> Option<PathBuf> {
    method new (line 276) | pub fn new() -> Self {
    method as_dist_abs (line 279) | pub fn as_dist_abs(&mut self, p: &Path) -> Option<String> {
    method as_dist (line 285) | pub fn as_dist(&mut self, p: &Path) -> Option<String> {
    method disk_mappings (line 288) | pub fn disk_mappings(&self) -> impl Iterator<Item = (PathBuf, String)> {
    method to_local (line 291) | pub fn to_local(&self, p: &str) -> Option<PathBuf> {
  function osstrings_to_strings (line 297) | pub fn osstrings_to_strings(osstrings: &[OsString]) -> Option<Vec<String...
  function osstring_tuples_to_strings (line 304) | pub fn osstring_tuples_to_strings(
  function strings_to_osstrings (line 313) | pub fn strings_to_osstrings(strings: &[String]) -> Vec<OsString> {
  function try_compile_command_to_dist (line 321) | pub fn try_compile_command_to_dist(
  type Toolchain (line 349) | pub struct Toolchain {
  type JobId (line 355) | pub struct JobId(pub u64);
    method fmt (line 357) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 362) | type Err = <u64 as FromStr>::Err;
  method from_str (line 363) | fn from_str(s: &str) -> ::std::result::Result<Self, Self::Err> {
  type ServerId (line 369) | pub struct ServerId(SocketAddr);
    method new (line 371) | pub fn new(addr: SocketAddr) -> Self {
    method addr (line 374) | pub fn addr(&self) -> SocketAddr {
  type Err (line 379) | type Err = <SocketAddr as FromStr>::Err;
  method from_str (line 380) | fn from_str(s: &str) -> ::std::result::Result<Self, Self::Err> {
  type ServerNonce (line 386) | pub struct ServerNonce(u64);
    method new (line 388) | pub fn new() -> Self {
  type JobState (line 395) | pub enum JobState {
    method fmt (line 402) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type CompileCommand (line 416) | pub struct CompileCommand {
  type ProcessOutput (line 428) | pub struct ProcessOutput {
    method try_from (line 435) | pub fn try_from(o: process::Output) -> Result<Self> {
    method fake_output (line 448) | pub fn fake_output(code: i32, stdout: Vec<u8>, stderr: Vec<u8>) -> Self {
  function exit_status (line 461) | fn exit_status(code: i32) -> process::ExitStatus {
  function exit_status (line 465) | fn exit_status(code: i32) -> process::ExitStatus {
  function from (line 471) | fn from(o: ProcessOutput) -> Self {
  type OutputData (line 483) | pub struct OutputData(Vec<u8>, u64);
    method try_from_reader (line 486) | pub fn try_from_reader<R: Read>(r: R) -> io::Result<Self> {
    method lens (line 494) | pub fn lens(&self) -> OutputDataLens {
    method into_reader (line 501) | pub fn into_reader(self) -> impl Read {
  type OutputDataLens (line 506) | pub struct OutputDataLens {
    method fmt (line 511) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type JobAlloc (line 524) | pub struct JobAlloc {
  type AllocJobResult (line 531) | pub enum AllocJobResult {
  type AssignJobResult (line 545) | pub struct AssignJobResult {
  type UpdateJobStateResult (line 554) | pub enum UpdateJobStateResult {
  type HeartbeatServerResult (line 563) | pub struct HeartbeatServerResult {
  type RunJobResult (line 571) | pub enum RunJobResult {
  type JobComplete (line 577) | pub struct JobComplete {
  type SchedulerStatusResult (line 586) | pub struct SchedulerStatusResult {
  type SubmitToolchainResult (line 596) | pub enum SubmitToolchainResult {
  type BuildResult (line 606) | pub struct BuildResult {
  type ToolchainReader (line 618) | pub struct ToolchainReader<'a>(Box<dyn Read + 'a>);
  method read (line 620) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  type InputsReader (line 625) | pub struct InputsReader<'a>(Box<dyn Read + Send + 'a>);
  method read (line 627) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  type ExtResult (line 633) | type ExtResult<T, E> = ::std::result::Result<T, E>;
  type SchedulerOutgoing (line 636) | pub trait SchedulerOutgoing {
    method do_assign_job (line 638) | fn do_assign_job(
  type ServerOutgoing (line 648) | pub trait ServerOutgoing {
    method do_update_job_state (line 650) | fn do_update_job_state(&self, job_id: JobId, state: JobState) -> Resul...
  type JobAuthorizer (line 655) | pub trait JobAuthorizer: Send {
    method generate_token (line 656) | fn generate_token(&self, job_id: JobId) -> Result<String>;
    method verify_token (line 657) | fn verify_token(&self, job_id: JobId, token: &str) -> Result<()>;
  type SchedulerIncoming (line 661) | pub trait SchedulerIncoming: Send + Sync {
    method handle_alloc_job (line 663) | fn handle_alloc_job(
    method handle_heartbeat_server (line 669) | fn handle_heartbeat_server(
    method handle_update_job_state (line 677) | fn handle_update_job_state(
    method handle_status (line 684) | fn handle_status(&self) -> ExtResult<SchedulerStatusResult, Error>;
  type ServerIncoming (line 688) | pub trait ServerIncoming: Send + Sync {
    method handle_assign_job (line 690) | fn handle_assign_job(&self, job_id: JobId, tc: Toolchain) -> ExtResult...
    method handle_submit_toolchain (line 692) | fn handle_submit_toolchain(
    method handle_run_job (line 699) | fn handle_run_job(
  type BuilderIncoming (line 710) | pub trait BuilderIncoming: Send + Sync {
    method run_build (line 712) | fn run_build(
  type Client (line 724) | pub trait Client: Send + Sync {
    method do_alloc_job (line 726) | async fn do_alloc_job(&self, tc: Toolchain) -> Result<AllocJobResult>;
    method do_get_status (line 728) | async fn do_get_status(&self) -> Result<SchedulerStatusResult>;
    method do_submit_toolchain (line 730) | async fn do_submit_toolchain(
    method do_run_job (line 736) | async fn do_run_job(
    method put_toolchain (line 743) | async fn put_toolchain(
    method rewrite_includes_only (line 749) | fn rewrite_includes_only(&self) -> bool;
    method get_custom_toolchain (line 750) | fn get_custom_toolchain(&self, exe: &Path) -> Option<PathBuf>;

FILE: src/dist/pkg.rs
  type ToolchainPackager (line 26) | pub trait ToolchainPackager: Send {
    method write_pkg (line 27) | fn write_pkg(self: Box<Self>, f: fs::File) -> Result<()>;
    method write_pkg (line 49) | fn write_pkg(self: Box<Self>, _f: fs::File) -> Result<()> {
  type InputsPackager (line 30) | pub trait InputsPackager: Send {
    method write_inputs (line 31) | fn write_inputs(self: Box<Self>, wtr: &mut dyn io::Write) -> Result<di...
  type OutputsRepackager (line 34) | pub trait OutputsRepackager {
    method repackage_outputs (line 35) | fn repackage_outputs(self: Box<Self>, wtr: &mut dyn io::Write)
  type ToolchainPackageBuilder (line 68) | pub struct ToolchainPackageBuilder {
    method new (line 79) | pub fn new() -> Self {
    method add_common (line 87) | pub fn add_common(&mut self) -> Result<()> {
    method add_executable_and_deps (line 91) | pub fn add_executable_and_deps(&mut self, executable: PathBuf) -> Resu...
    method add_dir (line 113) | pub fn add_dir(&mut self, dir_path: PathBuf) -> Result<()> {
    method add_file (line 134) | pub fn add_file(&mut self, file_path: PathBuf) -> Result<()> {
    method add_dir_contents (line 147) | pub fn add_dir_contents(&mut self, dir_path: &Path) -> Result<()> {
    method into_compressed_tar (line 172) | pub fn into_compressed_tar<W: Write + Send + 'static>(self, writer: W)...
    method tarify_path (line 210) | fn tarify_path(&mut self, path: &Path) -> Result<PathBuf> {
  function tar_safe_path (line 220) | fn tar_safe_path(path: PathBuf) -> PathBuf {
  function find_ldd_libraries (line 247) | fn find_ldd_libraries(executable: &Path) -> Result<Vec<PathBuf>> {
  function parse_ldd_output (line 293) | fn parse_ldd_output(stdout: &str) -> Vec<PathBuf> {
  function test_ldd_parse (line 345) | fn test_ldd_parse() {
  function test_ldd_parse_static (line 371) | fn test_ldd_parse_static() {
  function test_ldd_parse_v2_30 (line 382) | fn test_ldd_parse_v2_30() {
  function make_tar_header (line 405) | pub fn make_tar_header(src: &Path, dest: &str) -> io::Result<tar::Header> {
  function simplify_path (line 453) | pub fn simplify_path(path: &Path) -> Result<PathBuf> {
  type SimplifyPath (line 460) | struct SimplifyPath<'a> {
  function simplify (line 465) | pub fn simplify(&mut self, path: &Path) -> Result<PathBuf> {

FILE: src/errors.rs
  type BadHttpStatusError (line 27) | pub struct BadHttpStatusError(pub hyper::StatusCode);
    method fmt (line 44) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type HttpClientError (line 30) | pub struct HttpClientError(pub String);
    method fmt (line 50) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ProcessError (line 33) | pub struct ProcessError(pub process::Output);
    method fmt (line 56) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Result (line 61) | pub type Result<T> = anyhow::Result<T>;

FILE: src/jobserver.rs
  function discard_inherited_jobserver (line 37) | pub unsafe fn discard_inherited_jobserver() {
  type Client (line 74) | pub struct Client {
    method new (line 85) | pub fn new() -> Client {
    method new_num (line 89) | pub fn new_num(num: usize) -> Client {
    method _new (line 94) | fn _new(inner: jobserver::Client, inherited: bool) -> Client {
    method configure (line 119) | pub fn configure(&self, cmd: &mut Command) {
    method acquire (line 128) | pub async fn acquire(&self) -> Result<Acquired> {
  type Acquired (line 80) | pub struct Acquired {

FILE: src/lib.rs
  constant VERSION (line 58) | pub const VERSION: &str = env!("CARGO_PKG_VERSION");
  constant LOGGING_ENV (line 62) | pub const LOGGING_ENV: &str = "SCCACHE_LOG";
  function main (line 64) | pub fn main() {
  function init_logging (line 94) | fn init_logging() {

FILE: src/lru_disk_cache/lru_cache.rs
  type Meter (line 55) | pub trait Meter<K, V> {
    method measure (line 59) | fn measure<Q: ?Sized>(&self, key: &Q, value: &V) -> Self::Measure
  type Count (line 65) | pub struct Count;
    type Measure (line 69) | type Measure = ();
    method measure (line 72) | fn measure<Q: ?Sized>(&self, _: &Q, _: &V)
    method meter_add (line 138) | fn meter_add(&self, _current: (), _amount: ()) {}
    method meter_sub (line 139) | fn meter_sub(&self, _current: (), _amount: ()) {}
    method meter_size (line 140) | fn meter_size(&self, _current: ()) -> Option<u64> {
  type CountableMeter (line 81) | pub trait CountableMeter<K, V>: Meter<K, V> {
    method add (line 83) | fn add(&self, current: Self::Measure, amount: Self::Measure) -> Self::...
    method sub (line 85) | fn sub(&self, current: Self::Measure, amount: Self::Measure) -> Self::...
    method size (line 90) | fn size(&self, current: Self::Measure) -> Option<u64>;
  method add (line 98) | fn add(&self, current: Self::Measure, amount: Self::Measure) -> Self::Me...
  method sub (line 101) | fn sub(&self, current: Self::Measure, amount: Self::Measure) -> Self::Me...
  method size (line 104) | fn size(&self, current: Self::Measure) -> Option<u64> {
  type CountableMeterWithMeasure (line 109) | pub trait CountableMeterWithMeasure<K, V, M> {
    method meter_add (line 111) | fn meter_add(&self, current: M, amount: M) -> M;
    method meter_sub (line 113) | fn meter_sub(&self, current: M, amount: M) -> M;
    method meter_size (line 118) | fn meter_size(&self, current: M) -> Option<u64>;
  method meter_add (line 126) | fn meter_add(&self, current: usize, amount: usize) -> usize {
  method meter_sub (line 129) | fn meter_sub(&self, current: usize, amount: usize) -> usize {
  method meter_size (line 132) | fn meter_size(&self, current: usize) -> Option<u64> {
  type LruCache (line 147) | pub struct LruCache<K: Eq + Hash, V, S: BuildHasher = RandomState, M: Co...
  function new (line 164) | pub fn new(capacity: u64) -> Self {
  function with_meter (line 208) | pub fn with_meter(capacity: u64, meter: M) -> LruCache<K, V, RandomState...
  function with_hasher (line 220) | pub fn with_hasher(capacity: u64, hash_builder: S) -> LruCache<K, V, S, ...
  function get_mut (line 250) | pub fn get_mut<Q: Hash + Eq + ?Sized>(&mut self, k: &Q) -> Option<&mut V>
  function iter_mut (line 288) | pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
  function with_meter_and_hasher (line 296) | pub fn with_meter_and_hasher(capacity: u64, meter: M, hash_builder: S) -...
  function capacity (line 315) | pub fn capacity(&self) -> u64 {
  function contains_key (line 331) | pub fn contains_key<Q: Hash + Eq + ?Sized>(&self, key: &Q) -> bool
  function get (line 338) | pub fn get<Q: Hash + Eq + ?Sized>(&mut self, k: &Q) -> Option<&V>
  function insert (line 360) | pub fn insert(&mut self, k: K, v: V) -> Option<V> {
  function remove (line 391) | pub fn remove<Q: Hash + Eq + ?Sized>(&mut self, k: &Q) -> Option<V>
  function set_capacity (line 436) | pub fn set_capacity(&mut self, capacity: u64) {
  function remove_lru (line 459) | pub fn remove_lru(&mut self) -> Option<(K, V)> {
  function len (line 469) | pub fn len(&self) -> usize {
  function size (line 475) | pub fn size(&self) -> u64 {
  function is_empty (line 482) | pub fn is_empty(&self) -> bool {
  function clear (line 487) | pub fn clear(&mut self) {
  function iter (line 510) | pub fn iter(&self) -> Iter<'_, K, V> {
  function internal_iter_mut (line 514) | fn internal_iter_mut(&mut self) -> IterMut<'_, K, V> {
  function extend (line 522) | fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I) {
  function fmt (line 532) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 540) | type Item = (K, V);
  type IntoIter (line 541) | type IntoIter = IntoIter<K, V>;
  method into_iter (line 543) | fn into_iter(self) -> IntoIter<K, V> {
  type Item (line 551) | type Item = (&'a K, &'a V);
  type IntoIter (line 552) | type IntoIter = Iter<'a, K, V>;
  method into_iter (line 553) | fn into_iter(self) -> Iter<'a, K, V> {
  type Item (line 561) | type Item = (&'a K, &'a mut V);
  type IntoIter (line 562) | type IntoIter = IterMut<'a, K, V>;
  method into_iter (line 563) | fn into_iter(self) -> IterMut<'a, K, V> {
  type IntoIter (line 592) | pub struct IntoIter<K, V>(linked_hash_map::IntoIter<K, V>);
  type Item (line 595) | type Item = (K, V);
  method next (line 597) | fn next(&mut self) -> Option<(K, V)> {
  method size_hint (line 601) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next_back (line 607) | fn next_back(&mut self) -> Option<(K, V)> {
  method len (line 613) | fn len(&self) -> usize {
  type Iter (line 621) | pub struct Iter<'a, K, V>(linked_hash_map::Iter<'a, K, V>);
  method clone (line 624) | fn clone(&self) -> Iter<'a, K, V> {
  type Item (line 630) | type Item = (&'a K, &'a V);
  method next (line 631) | fn next(&mut self) -> Option<(&'a K, &'a V)> {
  method size_hint (line 634) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next_back (line 640) | fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
  method len (line 646) | fn len(&self) -> usize {
  type IterMut (line 655) | pub struct IterMut<'a, K, V>(linked_hash_map::IterMut<'a, K, V>);
  type Item (line 658) | type Item = (&'a K, &'a mut V);
  method next (line 659) | fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
  method size_hint (line 662) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next_back (line 668) | fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> {
  method len (line 674) | fn len(&self) -> usize {
  function test_put_and_get (line 685) | fn test_put_and_get() {
  function test_put_update (line 696) | fn test_put_update() {
  function test_contains_key (line 705) | fn test_contains_key() {
  function test_expire_lru (line 712) | fn test_expire_lru() {
  function test_pop (line 724) | fn test_pop() {
  function test_change_capacity (line 737) | fn test_change_capacity() {
  function test_debug (line 748) | fn test_debug() {
  function test_remove (line 765) | fn test_remove() {
  function test_clear (line 786) | fn test_clear() {
  function test_iter (line 797) | fn test_iter() {
  type VecLen (line 822) | struct VecLen;
    type Measure (line 825) | type Measure = usize;
    method measure (line 826) | fn measure<Q: ?Sized>(&self, _: &Q, v: &Vec<T>) -> usize
  function test_metered_cache (line 835) | fn test_metered_cache() {
  function test_metered_cache_reinsert_larger (line 851) | fn test_metered_cache_reinsert_larger() {
  function test_metered_cache_oversize (line 862) | fn test_metered_cache_oversize() {

FILE: src/lru_disk_cache/mod.rs
  constant TEMPFILE_PREFIX (line 23) | const TEMPFILE_PREFIX: &str = ".sccachetmp";
  type FileSize (line 25) | struct FileSize;
    type Measure (line 29) | type Measure = usize;
    method measure (line 30) | fn measure<Q: ?Sized>(&self, _: &Q, v: &u64) -> usize
  function get_all_files (line 40) | fn get_all_files<P: AsRef<Path>>(path: P) -> Box<dyn Iterator<Item = (Pa...
  type LruDiskCache (line 65) | pub struct LruDiskCache<S: BuildHasher = RandomState> {
    method new (line 143) | pub fn new<T>(path: T, size: u64) -> Result<Self>
    method size (line 157) | pub fn size(&self) -> u64 {
    method len (line 162) | pub fn len(&self) -> usize {
    method is_empty (line 166) | pub fn is_empty(&self) -> bool {
    method capacity (line 171) | pub fn capacity(&self) -> u64 {
    method path (line 176) | pub fn path(&self) -> &Path {
    method rel_to_abs_path (line 181) | fn rel_to_abs_path<K: AsRef<Path>>(&self, rel_path: K) -> PathBuf {
    method init (line 186) | fn init(mut self) -> Result<Self> {
    method can_store (line 213) | pub fn can_store(&self, size: u64) -> bool {
    method make_space (line 217) | fn make_space(&mut self, size: u64) -> Result<()> {
    method add_file (line 250) | fn add_file(&mut self, addfile_path: AddFile<'_>, size: u64) -> Result...
    method insert_by (line 260) | fn insert_by<K: AsRef<OsStr>, F: FnOnce(&Path) -> io::Result<()>>(
    method insert_with (line 293) | pub fn insert_with<K: AsRef<OsStr>, F: FnOnce(File) -> io::Result<()>>(
    method insert_bytes (line 302) | pub fn insert_bytes<K: AsRef<OsStr>>(&mut self, key: K, bytes: &[u8]) ...
    method insert_file (line 311) | pub fn insert_file<K: AsRef<OsStr>, P: AsRef<OsStr>>(&mut self, key: K...
    method prepare_add (line 327) | pub fn prepare_add<'a, K: AsRef<OsStr> + 'a>(
    method commit (line 345) | pub fn commit(&mut self, entry: LruDiskCacheAddEntry) -> Result<()> {
    method contains_key (line 371) | pub fn contains_key<K: AsRef<OsStr>>(&self, key: K) -> bool {
    method get_file (line 379) | pub fn get_file<K: AsRef<OsStr>>(&mut self, key: K) -> Result<File> {
    method get (line 396) | pub fn get<K: AsRef<OsStr>>(&mut self, key: K) -> Result<Box<dyn ReadS...
    method remove (line 401) | pub fn remove<K: AsRef<OsStr>>(&mut self, key: K) -> Result<()> {
  type Error (line 74) | pub enum Error {
    method fmt (line 84) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 104) | fn from(e: io::Error) -> Error {
  method source (line 94) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  type Result (line 110) | pub type Result<T> = std::result::Result<T, Error>;
  type ReadSeek (line 113) | pub trait ReadSeek: Read + Seek + Send {}
  type AddFile (line 117) | enum AddFile<'a> {
  type LruDiskCacheAddEntry (line 122) | pub struct LruDiskCacheAddEntry {
    method as_file_mut (line 129) | pub fn as_file_mut(&mut self) -> &mut std::fs::File {
  type TestFixture (line 425) | struct TestFixture {
    method new (line 457) | pub fn new() -> TestFixture {
    method tmp (line 466) | pub fn tmp(&self) -> &Path {
    method create_file (line 470) | pub fn create_file<T: AsRef<Path>>(&self, path: T, size: usize) -> Pat...
  function create_file (line 430) | fn create_file<T: AsRef<Path>, F: FnOnce(File) -> io::Result<()>>(
  function set_mtime_back (line 443) | fn set_mtime_back<T: AsRef<Path>>(path: T, seconds: usize) {
  function read_all (line 450) | fn read_all<R: Read>(r: &mut R) -> io::Result<Vec<u8>> {
  function test_empty_dir (line 479) | fn test_empty_dir() {
  function test_missing_root (line 485) | fn test_missing_root() {
  function test_some_existing_files (line 491) | fn test_some_existing_files() {
  function test_existing_file_too_large (line 501) | fn test_existing_file_too_large() {
  function test_existing_files_lru_mtime (line 514) | fn test_existing_files_lru_mtime() {
  function test_insert_bytes (line 529) | fn test_insert_bytes() {
  function test_insert_bytes_exact (line 545) | fn test_insert_bytes_exact() {
  function test_add_get_lru (line 558) | fn test_add_get_lru() {
  function test_insert_bytes_too_large (line 601) | fn test_insert_bytes_too_large() {
  function test_insert_file (line 611) | fn test_insert_file() {
  function test_prepare_and_commit (line 638) | fn test_prepare_and_commit() {
  function test_remove (line 701) | fn test_remove() {

FILE: src/main.rs
  function main (line 17) | fn main() {

FILE: src/mock_command.rs
  type CommandChild (line 63) | pub trait CommandChild {
    method take_stdin (line 72) | fn take_stdin(&mut self) -> Option<Self::I>;
    method take_stdout (line 74) | fn take_stdout(&mut self) -> Option<Self::O>;
    method take_stderr (line 76) | fn take_stderr(&mut self) -> Option<Self::E>;
    method wait (line 78) | async fn wait(self) -> io::Result<ExitStatus>;
    method wait_with_output (line 80) | async fn wait_with_output(self) -> io::Result<Output>;
    type I (line 151) | type I = ChildStdin;
    type O (line 152) | type O = ChildStdout;
    type E (line 153) | type E = ChildStderr;
    method take_stdin (line 155) | fn take_stdin(&mut self) -> Option<ChildStdin> {
    method take_stdout (line 158) | fn take_stdout(&mut self) -> Option<ChildStdout> {
    method take_stderr (line 161) | fn take_stderr(&mut self) -> Option<ChildStderr> {
    method wait (line 165) | async fn wait(self) -> io::Result<ExitStatus> {
    method wait_with_output (line 172) | async fn wait_with_output(self) -> io::Result<Output> {
    type I (line 371) | type I = io::Cursor<Vec<u8>>;
    type O (line 372) | type O = io::Cursor<Vec<u8>>;
    type E (line 373) | type E = io::Cursor<Vec<u8>>;
    method take_stdin (line 375) | fn take_stdin(&mut self) -> Option<io::Cursor<Vec<u8>>> {
    method take_stdout (line 378) | fn take_stdout(&mut self) -> Option<io::Cursor<Vec<u8>>> {
    method take_stderr (line 381) | fn take_stderr(&mut self) -> Option<io::Cursor<Vec<u8>>> {
    method wait (line 385) | async fn wait(mut self) -> io::Result<ExitStatus> {
    method wait_with_output (line 389) | async fn wait_with_output(self) -> io::Result<Output> {
  type RunCommand (line 85) | pub trait RunCommand: fmt::Debug + Send {
    method arg (line 90) | fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self;
    method args (line 92) | fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut Self;
    method env (line 94) | fn env<K, V>(&mut self, key: K, val: V) -> &mut Self
    method envs (line 99) | fn envs<I, K, V>(&mut self, vars: I) -> &mut Self
    method env_clear (line 105) | fn env_clear(&mut self) -> &mut Self;
    method current_dir (line 107) | fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self;
    method stdin (line 109) | fn stdin(&mut self, cfg: Stdio) -> &mut Self;
    method stdout (line 111) | fn stdout(&mut self, cfg: Stdio) -> &mut Self;
    method stderr (line 113) | fn stderr(&mut self, cfg: Stdio) -> &mut Self;
    method spawn (line 115) | async fn spawn(&mut self) -> Result<Self::C>;
    type C (line 201) | type C = Child;
    method arg (line 203) | fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut AsyncCommand {
    method args (line 207) | fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut AsyncCommand {
    method env (line 211) | fn env<K, V>(&mut self, key: K, val: V) -> &mut AsyncCommand
    method envs (line 219) | fn envs<I, K, V>(&mut self, vars: I) -> &mut Self
    method env_clear (line 228) | fn env_clear(&mut self) -> &mut AsyncCommand {
    method current_dir (line 232) | fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut AsyncCommand {
    method stdin (line 237) | fn stdin(&mut self, cfg: Stdio) -> &mut AsyncCommand {
    method stdout (line 241) | fn stdout(&mut self, cfg: Stdio) -> &mut AsyncCommand {
    method stderr (line 245) | fn stderr(&mut self, cfg: Stdio) -> &mut AsyncCommand {
    method spawn (line 249) | async fn spawn(&mut self) -> Result<Child> {
    type C (line 429) | type C = MockChild;
    method arg (line 431) | fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut MockCommand {
    method args (line 435) | fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut MockCommand {
    method env (line 439) | fn env<K, V>(&mut self, _key: K, _val: V) -> &mut MockCommand
    method envs (line 446) | fn envs<I, K, V>(&mut self, _vars: I) -> &mut Self
    method env_clear (line 454) | fn env_clear(&mut self) -> &mut MockCommand {
    method current_dir (line 457) | fn current_dir<P: AsRef<Path>>(&mut self, _dir: P) -> &mut MockCommand {
    method stdin (line 461) | fn stdin(&mut self, _cfg: Stdio) -> &mut MockCommand {
    method stdout (line 464) | fn stdout(&mut self, _cfg: Stdio) -> &mut MockCommand {
    method stderr (line 467) | fn stderr(&mut self, _cfg: Stdio) -> &mut MockCommand {
    method spawn (line 470) | async fn spawn(&mut self) -> Result<MockChild> {
  type CommandCreator (line 123) | pub trait CommandCreator {
    method new (line 128) | fn new(client: &Client) -> Self;
    method new_command (line 131) | fn new_command<S: AsRef<OsStr>>(&mut self, program: S) -> Self::Cmd;
    type Cmd (line 283) | type Cmd = AsyncCommand;
    method new (line 285) | fn new(client: &Client) -> ProcessCommandCreator {
    method new_command (line 291) | fn new_command<S: AsRef<OsStr>>(&mut self, program: S) -> AsyncCommand {
    type Cmd (line 504) | type Cmd = MockCommand;
    method new (line 506) | fn new(_client: &Client) -> MockCommandCreator {
    method new_command (line 512) | fn new_command<S: AsRef<OsStr>>(&mut self, _program: S) -> MockCommand {
  type CommandCreatorSync (line 135) | pub trait CommandCreatorSync: Clone + Send + Sync + 'static {
    method new (line 138) | fn new(client: &Client) -> Self;
    method new_command_sync (line 140) | fn new_command_sync<S: AsRef<OsStr>>(&mut self, program: S) -> Self::Cmd;
    type Cmd (line 298) | type Cmd = AsyncCommand;
    method new (line 300) | fn new(client: &Client) -> ProcessCommandCreator {
    method new_command_sync (line 304) | fn new_command_sync<S: AsRef<OsStr>>(&mut self, program: S) -> AsyncCo...
    type Cmd (line 527) | type Cmd = T::Cmd;
    method new (line 529) | fn new(client: &Client) -> Arc<Mutex<T>> {
    method new_command_sync (line 533) | fn new_command_sync<S: AsRef<OsStr>>(&mut self, program: S) -> T::Cmd {
  type Child (line 143) | pub struct Child {
  type AsyncCommand (line 180) | pub struct AsyncCommand {
    method new (line 186) | pub fn new<S: AsRef<OsStr>>(program: S, jobserver: Client) -> AsyncCom...
    method inner (line 193) | fn inner(&mut self) -> &mut Command {
    method fmt (line 270) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ProcessCommandCreator (line 277) | pub struct ProcessCommandCreator {
  type ExitStatusValue (line 316) | pub type ExitStatusValue = i32;
  type ExitStatusValue (line 318) | pub type ExitStatusValue = u32;
  function exit_status (line 321) | pub fn exit_status(v: ExitStatusValue) -> ExitStatus {
  type MockChild (line 328) | pub struct MockChild {
    method new (line 344) | pub fn new<T: AsRef<[u8]>, U: AsRef<[u8]>>(
    method with_error (line 359) | pub fn with_error(err: io::Error) -> MockChild {
  type ChildOrCall (line 405) | pub enum ChildOrCall {
    method fmt (line 411) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type MockCommand (line 422) | pub struct MockCommand {
  type MockCommandCreator (line 480) | pub struct MockCommandCreator {
    method next_command_spawns (line 488) | pub fn next_command_spawns(&mut self, child: Result<MockChild>) {
    method next_command_calls (line 495) | pub fn next_command_calls<C>(&mut self, call: C)
  function spawn_command (line 549) | fn spawn_command<T: CommandCreator, S: AsRef<OsStr>>(
  function spawn_wait_command (line 556) | fn spawn_wait_command<T: CommandCreator, S: AsRef<OsStr>>(
  function spawn_output_command (line 563) | fn spawn_output_command<T: CommandCreator, S: AsRef<OsStr>>(
  function spawn_on_thread (line 570) | fn spawn_on_thread<T: CommandCreatorSync + Send + 'static>(
  function test_mock_command_wait (line 592) | fn test_mock_command_wait() {
  function test_unexpected_new_command (line 607) | fn test_unexpected_new_command() {
  function test_mock_command_output (line 616) | fn test_mock_command_output() {
  function test_mock_command_calls (line 627) | fn test_mock_command_calls() {
  function test_mock_spawn_error (line 638) | fn test_mock_spawn_error() {
  function test_mock_wait_error (line 647) | fn test_mock_wait_error() {
  function test_mock_command_sync (line 656) | fn test_mock_command_sync() {

FILE: src/net.rs
  type SocketAddr (line 26) | pub enum SocketAddr {
    method fmt (line 36) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method with_port (line 50) | pub fn with_port(port: u16) -> Self {
    method as_net (line 55) | pub fn as_net(&self) -> Option<&std::net::SocketAddr> {
    method parse_uds (line 67) | pub fn parse_uds(s: &str) -> std::io::Result<Self> {
    method is_unix_path (line 82) | pub fn is_unix_path(&self) -> bool {
    method is_unix_path (line 87) | pub fn is_unix_path(&self) -> bool {
  type Acceptor (line 93) | pub trait Acceptor {
    method accept (line 96) | fn accept(&self) -> impl Future<Output = tokio::io::Result<Self::Socke...
    method local_addr (line 97) | fn local_addr(&self) -> tokio::io::Result<Option<SocketAddr>>;
    type Socket (line 101) | type Socket = tokio::net::TcpStream;
    method accept (line 104) | fn accept(&self) -> impl Future<Output = tokio::io::Result<Self::Socke...
    method local_addr (line 109) | fn local_addr(&self) -> tokio::io::Result<Option<SocketAddr>> {
    type Socket (line 154) | type Socket = tokio::net::UnixStream;
    method accept (line 157) | fn accept(&self) -> impl Future<Output = tokio::io::Result<Self::Socke...
    method local_addr (line 162) | fn local_addr(&self) -> tokio::io::Result<Option<SocketAddr>> {
  type Connection (line 115) | pub trait Connection: std::io::Read + std::io::Write {
    method try_clone (line 116) | fn try_clone(&self) -> std::io::Result<Box<dyn Connection>>;
    method try_clone (line 121) | fn try_clone(&self) -> std::io::Result<Box<dyn Connection>> {
    method try_clone (line 179) | fn try_clone(&self) -> std::io::Result<Box<dyn Connection>> {
  function connect (line 129) | pub fn connect(addr: &SocketAddr) -> std::io::Result<Box<dyn Connection>> {

FILE: src/protocol.rs
  type Request (line 8) | pub enum Request {
  type Response (line 23) | pub enum Response {
  type CompileResponse (line 40) | pub enum CompileResponse {
  type CompileFinished (line 51) | pub struct CompileFinished {
  type Compile (line 66) | pub struct Compile {

FILE: src/server.rs
  constant DEFAULT_IDLE_TIMEOUT (line 75) | const DEFAULT_IDLE_TIMEOUT: u64 = 600;
  constant DIST_CLIENT_RECREATE_TIMEOUT (line 80) | const DIST_CLIENT_RECREATE_TIMEOUT: Duration = Duration::from_secs(30);
  type ServerStartup (line 84) | pub enum ServerStartup {
  function get_idle_timeout (line 96) | fn get_idle_timeout() -> u64 {
  function notify_server_startup_internal (line 104) | fn notify_server_startup_internal<W: Write>(mut w: W, status: ServerStar...
  function notify_server_startup (line 109) | fn notify_server_startup(name: Option<&OsString>, status: ServerStartup)...
  function notify_server_startup (line 121) | fn notify_server_startup(name: Option<&OsString>, status: ServerStartup)...
  function get_signal (line 133) | fn get_signal(status: ExitStatus) -> i32 {
  function get_signal (line 138) | fn get_signal(_status: ExitStatus) -> i32 {
  type DistClientContainer (line 142) | pub struct DistClientContainer {
    method new (line 176) | fn new(config: &Config, _: &tokio::runtime::Handle) -> Self {
    method new_disabled (line 185) | pub fn new_disabled() -> Self {
    method new_with_state (line 190) | pub fn new_with_state(_: DistClientState) -> Self {
    method reset_state (line 194) | pub async fn reset_state(&self) {}
    method get_status (line 196) | pub async fn get_status(&self) -> DistInfo {
    method get_client (line 200) | async fn get_client(&self) -> Result<Option<Arc<dyn dist::Client>>> {
    method new (line 207) | fn new(config: &Config, pool: &tokio::runtime::Handle) -> Self {
    method new_with_state (line 225) | pub fn new_with_state(state: DistClientState) -> Self {
    method new_disabled (line 231) | pub fn new_disabled() -> Self {
    method reset_state (line 237) | pub async fn reset_state(&self) {
    method get_status (line 254) | pub async fn get_status(&self) -> DistInfo {
    method get_client (line 286) | async fn get_client(&self) -> Result<Option<Arc<dyn dist::Client>>> {
    method maybe_recreate_state (line 310) | async fn maybe_recreate_state(state: &mut DistClientState) {
    method create_state (line 325) | async fn create_state(config: DistClientConfig) -> DistClientState {
    method get_cached_config_auth_token (line 411) | fn get_cached_config_auth_token(auth_url: &str) -> Result<String> {
  type DistClientConfig (line 149) | pub struct DistClientConfig {
  type DistClientState (line 163) | pub enum DistClientState {
  function start_server (line 430) | pub fn start_server(config: &Config, addr: &crate::net::SocketAddr) -> R...
  type SccacheServer (line 571) | pub struct SccacheServer<A: crate::net::Acceptor, C: CommandCreatorSync ...
  function new (line 581) | pub fn new(
  function with_listener (line 602) | pub fn with_listener(
  function set_idle_timeout (line 628) | pub fn set_idle_timeout(&mut self, timeout: Duration) {
  function set_storage (line 634) | pub fn set_storage(&mut self, storage: Arc<dyn Storage>) {
  function pool (line 640) | pub fn pool(&self) -> &tokio::runtime::Handle {
  function command_creator (line 646) | pub fn command_creator(&self) -> &C {
  function local_addr (line 652) | pub fn local_addr(&self) -> Option<crate::net::SocketAddr> {
  function run (line 661) | pub fn run<F>(self, shutdown: F) -> io::Result<()>
  type CompilerProxyMap (line 754) | type CompilerProxyMap<C> = HashMap<PathBuf, (Box<dyn CompilerProxy<C>>, ...
  type CompilerMap (line 755) | type CompilerMap<C> = HashMap<PathBuf, Option<CompilerCacheEntry<C>>>;
  type CompilerCacheEntry (line 758) | struct CompilerCacheEntry<C> {
  function new (line 768) | fn new(
  type SccacheService (line 782) | pub struct SccacheService<C>
  type SccacheRequest (line 828) | type SccacheRequest = Message<Request, Body<()>>;
  type SccacheResponse (line 829) | type SccacheResponse = Message<Response, Pin<Box<dyn Future<Output = Res...
  type ServerMessage (line 836) | pub enum ServerMessage {
  type Response (line 847) | type Response = SccacheResponse;
  type Error (line 848) | type Error = Error;
  type Future (line 849) | type Future = Pin<Box<dyn Future<Output = Result<Self::Response>> + Send...
    type Output (line 2162) | type Output = ();
    method poll (line 2164) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  function call (line 851) | fn call(&mut self, req: SccacheRequest) -> Self::Future {
  function poll_ready (line 905) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<()>> {
  function new (line 917) | pub fn new(
  function mock_with_storage (line 938) | pub fn mock_with_storage(
  function mock_with_dist_client (line 960) | pub fn mock_with_dist_client(
  function bind (line 994) | fn bind<T>(self, socket: T) -> impl Future<Output = Result<()>> + Send +...
  function get_dist_status (line 1041) | async fn get_dist_status(&self) -> Result<DistInfo> {
  function get_info (line 1046) | async fn get_info(&self) -> Result<ServerInfo> {
  function zero_stats (line 1052) | async fn zero_stats(&self) {
  function handle_compile (line 1061) | async fn handle_compile(&self, compile: Compile) -> Result<SccacheRespon...
  function compiler_info (line 1076) | pub async fn compiler_info(
  function check_compiler (line 1233) | async fn check_compiler(
  function start_compile_task (line 1295) | pub async fn start_compile_task(
  type PerLanguageCount (line 1549) | pub struct PerLanguageCount {
    method increment (line 1555) | fn increment(&mut self, kind: &CompilerKind, lang: &Language) {
    method all (line 1565) | pub fn all(&self) -> u64 {
    method get (line 1569) | pub fn get(&self, key: &str) -> Option<&u64> {
    method get_adv (line 1573) | pub fn get_adv(&self, key: &str) -> Option<&u64> {
    method new (line 1577) | pub fn new() -> PerLanguageCount {
  type ServerStats (line 1584) | pub struct ServerStats {
    method print (line 1699) | fn print<T: ServerStatsWriter>(&self, writer: &mut T, advanced: bool) ...
    method set_percentage_stats (line 1866) | fn set_percentage_stats(&self, stats_vec: &mut Vec<(String, String, us...
  type ServerInfo (line 1634) | pub struct ServerInfo {
    method new (line 1933) | pub async fn new(stats: ServerStats, storage: Option<&dyn Storage>) ->...
    method print (line 1971) | pub fn print(&self, advanced: bool) {
  type DistInfo (line 1646) | pub enum DistInfo {
  method default (line 1655) | fn default() -> ServerStats {
  type ServerStatsWriter (line 1683) | pub trait ServerStatsWriter {
    method write (line 1684) | fn write(&mut self, text: &str);
    method write (line 1690) | fn write(&mut self, text: &str) {
    method write (line 2275) | fn write(&mut self, text: &str) {
  type StdoutServerStatsWriter (line 1687) | pub struct StdoutServerStatsWriter;
  function set_percentage_stat (line 1918) | fn set_percentage_stat(
  type Frame (line 2031) | enum Frame<R, R1> {
  type Body (line 2036) | struct Body<R> {
  type Item (line 2041) | type Item = Result<R>;
  function poll_next (line 2042) | fn poll_next(
  type Message (line 2050) | enum Message<R, B> {
  function into_inner (line 2056) | fn into_inner(self) -> R {
  type BincodeCodec (line 2064) | struct BincodeCodec;
    type Error (line 2069) | type Error = Error;
    method serialize (line 2071) | fn serialize(self: Pin<&mut Self>, item: &T) -> std::result::Result<By...
    type Error (line 2082) | type Error = Error;
    method deserialize (line 2084) | fn deserialize(self: Pin<&mut Self>, buf: &BytesMut) -> std::result::R...
  type SccacheTransport (line 2105) | struct SccacheTransport<I: AsyncRead + AsyncWrite + Unpin> {
  type Item (line 2122) | type Item = Result<Message<Request, Body<()>>>;
  method poll_next (line 2124) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Error (line 2132) | type Error = Error;
  function poll_ready (line 2134) | fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  function start_send (line 2138) | fn start_send(mut self: Pin<&mut Self>, item: Frame<Response, Response>)...
  function poll_flush (line 2146) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  function poll_close (line 2150) | fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  type ShutdownOrInactive (line 2155) | struct ShutdownOrInactive {
  type WaitUntilZero (line 2188) | struct WaitUntilZero {
    method new (line 2212) | fn new() -> (WaitUntilZero, ActiveInfo) {
    type Output (line 2220) | type Output = ();
    method poll (line 2222) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> std::task::Poll...
  type ActiveInfo (line 2194) | pub struct ActiveInfo {
  type Info (line 2198) | struct Info {
  method drop (line 2203) | fn drop(&mut self) {
  function waits_until_zero (line 2235) | fn waits_until_zero() {
  type StringWriter (line 2258) | struct StringWriter {
    method new (line 2263) | fn new() -> StringWriter {
    method get_output (line 2269) | fn get_output(self) -> String {
  function test_print_cache_hits_rate_default_server_stats (line 2281) | fn test_print_cache_hits_rate_default_server_stats() {
  function test_print_cache_hits_rate_server_stats (line 2293) | fn test_print_cache_hits_rate_server_stats() {
  function test_print_cache_hits_rate_advanced_server_stats (line 2326) | fn test_print_cache_hits_rate_advanced_server_stats() {
  function test_print_deterministic_hits (line 2361) | fn test_print_deterministic_hits() {

FILE: src/test/mock_storage.rs
  type MockStorage (line 26) | pub struct MockStorage {
    method new (line 35) | pub(crate) fn new(delay: Option<Duration>, preprocessor_cache_mode: bo...
    method next_get (line 46) | pub(crate) fn next_get(&self, res: Result<Cache>) {
  method get (line 53) | async fn get(&self, _key: &str) -> Result<Cache> {
  method put (line 61) | async fn put(&self, _key: &str, _entry: CacheWrite) -> Result<Duration> {
  method location (line 69) | fn location(&self) -> String {
  method current_size (line 72) | async fn current_size(&self) -> Result<Option<u64>> {
  method max_size (line 75) | async fn max_size(&self) -> Result<Option<u64>> {
  method preprocessor_cache_mode_config (line 78) | fn preprocessor_cache_mode_config(&self) -> PreprocessorCacheModeConfig {

FILE: src/test/tests.rs
  type ServerOptions (line 42) | struct ServerOptions {
  function run_server_thread (line 57) | fn run_server_thread<T>(
  function test_server_shutdown (line 111) | fn test_server_shutdown() {
  function test_server_shutdown_no_idle (line 124) | fn test_server_shutdown_no_idle() {
  function test_server_idle_timeout (line 141) | fn test_server_idle_timeout() {
  function test_server_stats (line 159) | fn test_server_stats() {
  function test_server_unsupported_compiler (line 176) | fn test_server_unsupported_compiler() {
  function test_server_compile (line 226) | fn test_server_compile() {
  function test_server_port_in_use (line 302) | fn test_server_port_in_use() {

FILE: src/test/utils.rs
  function new_creator (line 85) | pub fn new_creator() -> Arc<Mutex<MockCommandCreator>> {
  function next_command (line 90) | pub fn next_command(creator: &Arc<Mutex<MockCommandCreator>>, child: Res...
  function next_command_calls (line 94) | pub fn next_command_calls<C: Fn(&[OsString]) -> Result<MockChild> + Send...
  function find_sccache_binary (line 102) | pub fn find_sccache_binary() -> PathBuf {
  type TestFixture (line 120) | pub struct TestFixture {
    method new (line 202) | pub fn new() -> TestFixture {
    method touch (line 225) | pub fn touch(&self, path: &str) -> io::Result<PathBuf> {
    method mk_bin (line 230) | pub fn mk_bin(&self, path: &str) -> io::Result<PathBuf> {
  constant SUBDIRS (line 129) | pub const SUBDIRS: &[&str] = &["a", "b", "c"];
  constant BIN_NAME (line 130) | pub const BIN_NAME: &str = "bin";
  function create_file (line 132) | pub fn create_file<F>(dir: &Path, path: &str, fill_contents: F) -> io::R...
  function touch (line 144) | pub fn touch(dir: &Path, path: &str) -> io::Result<PathBuf> {
  function mk_bin_contents (line 149) | pub fn mk_bin_contents<F: FnOnce(File) -> io::Result<()>>(
  function mk_bin (line 169) | pub fn mk_bin(dir: &Path, path: &str) -> io::Result<PathBuf> {
  function mk_bin_contents (line 175) | pub fn mk_bin_contents<F: FnOnce(File) -> io::Result<()>>(
  function mk_bin (line 191) | pub fn mk_bin(dir: &Path, path: &str) -> io::Result<PathBuf> {
  function single_threaded_runtime (line 235) | pub fn single_threaded_runtime() -> tokio::runtime::Runtime {
  type Waiter (line 247) | pub(crate) trait Waiter<R> {
    method wait (line 248) | fn wait(self) -> R;
  method wait (line 255) | fn wait(self) -> O {
  function test_map_contains_ok (line 262) | fn test_map_contains_ok() {
  function test_map_contains_extra_key (line 271) | fn test_map_contains_extra_key() {
  function test_map_contains_missing_key (line 280) | fn test_map_contains_missing_key() {
  function test_map_contains_wrong_value (line 288) | fn test_map_contains_wrong_value() {

FILE: src/util.rs
  constant BASE64_URL_SAFE_ENGINE (line 37) | pub const BASE64_URL_SAFE_ENGINE: base64::engine::GeneralPurpose =
  constant HASH_BUFFER_SIZE (line 40) | pub const HASH_BUFFER_SIZE: usize = 128 * 1024;
  type Digest (line 43) | pub struct Digest {
    method new (line 48) | pub fn new() -> Digest {
    method file (line 56) | pub async fn file<T>(path: T, pool: &tokio::runtime::Handle) -> Result...
    method reader_sync (line 64) | pub fn reader_sync<R: Read>(reader: R) -> Result<String> {
    method reader_sync_with (line 70) | pub fn reader_sync_with<R: Read, F: FnMut(&[u8])>(mut reader: R, mut e...
    method reader_sync_time_macros (line 89) | pub fn reader_sync_time_macros<R: Read>(reader: R) -> Result<(String, ...
    method reader (line 100) | pub async fn reader(path: PathBuf, pool: &tokio::runtime::Handle) -> R...
    method update (line 109) | pub fn update(&mut self, bytes: &[u8]) {
    method delimiter (line 113) | pub fn delimiter(&mut self, name: &[u8]) {
    method finish (line 119) | pub fn finish(self) -> String {
  method default (line 125) | fn default() -> Self {
  constant MAX_HAYSTACK_LEN (line 131) | const MAX_HAYSTACK_LEN: usize = b"__TIMESTAMP__".len();
  constant MAX_TIME_MACRO_HAYSTACK_LEN (line 134) | pub const MAX_TIME_MACRO_HAYSTACK_LEN: usize = MAX_HAYSTACK_LEN;
  type TimeMacroFinder (line 142) | pub struct TimeMacroFinder {
    method find_time_macros (line 196) | pub fn find_time_macros(&mut self, visit: &[u8]) {
    method find_macros (line 268) | fn find_macros(&self, buffer: &[u8]) {
    method found_time_macros (line 287) | pub fn found_time_macros(&self) -> bool {
    method found_time (line 291) | pub fn found_time(&self) -> bool {
    method found_date (line 295) | pub fn found_date(&self) -> bool {
    method found_timestamp (line 299) | pub fn found_timestamp(&self) -> bool {
    method new (line 303) | pub fn new() -> Self {
  function hex (line 308) | pub fn hex(bytes: &[u8]) -> String {
  function hash_all (line 326) | pub async fn hash_all(files: &[PathBuf], pool: &tokio::runtime::Handle) ...
  function hash_all_archives (line 346) | pub async fn hash_all_archives(
  function hash_regular_archive (line 391) | fn hash_regular_archive(m: &mut Digest, data: &[u8]) -> Result<()> {
  function fmt_duration_as_secs (line 402) | pub fn fmt_duration_as_secs(duration: &Duration) -> String {
  function wait_with_input_output (line 410) | async fn wait_with_input_output<T>(mut child: T, input: Option<Vec<u8>>)...
  function run_input_output (line 472) | pub async fn run_input_output<C>(mut command: C, input: Option<Vec<u8>>)...
  function write_length_prefixed_bincode (line 499) | pub fn write_length_prefixed_bincode<W, S>(mut writer: W, data: S) -> Re...
  type OsStrExt (line 513) | pub trait OsStrExt {
    method starts_with (line 514) | fn starts_with(&self, s: &str) -> bool;
    method split_prefix (line 515) | fn split_prefix(&self, s: &str) -> Option<OsString>;
    method starts_with (line 523) | fn starts_with(&self, s: &str) -> bool {
    method split_prefix (line 527) | fn split_prefix(&self, s: &str) -> Option<OsString> {
    method starts_with (line 542) | fn starts_with(&self, s: &str) -> bool {
    method split_prefix (line 580) | fn split_prefix(&self, s: &str) -> Option<OsString> {
  function encode_path (line 616) | pub fn encode_path(dst: &mut dyn Write, path: &Path) -> std::io::Result<...
  function encode_path (line 624) | pub fn encode_path(dst: &mut dyn Write, path: &Path) -> std::io::Result<...
  function decode_path (line 633) | pub fn decode_path(bytes: &[u8]) -> std::io::Result<PathBuf> {
  function decode_path (line 639) | pub fn decode_path(bytes: &[u8]) -> std::io::Result<PathBuf> {
  function wide_char_to_multi_byte (line 649) | pub fn wide_char_to_multi_byte(wide_char_str: &[u16]) -> std::io::Result...
  function multi_byte_to_wide_char (line 702) | pub fn multi_byte_to_wide_char(
  type Timestamp (line 744) | pub struct Timestamp {
    method from (line 753) | fn from(system_time: std::time::SystemTime) -> Self {
    method eq (line 793) | fn eq(&self, other: &SystemTime) -> bool {
    method new (line 799) | pub fn new(seconds: i64, nanoseconds: u32) -> Self {
  constant NSEC_PER_SEC (line 750) | const NSEC_PER_SEC: u32 = 1_000_000_000;
  type MetadataCtimeExt (line 808) | pub trait MetadataCtimeExt {
    method ctime_or_creation (line 809) | fn ctime_or_creation(&self) -> std::io::Result<Timestamp>;
    method ctime_or_creation (line 814) | fn ctime_or_creation(&self) -> std::io::Result<Timestamp> {
    method ctime_or_creation (line 822) | fn ctime_or_creation(&self) -> std::io::Result<Timestamp> {
  type HashToDigest (line 829) | pub struct HashToDigest<'a> {
  method write (line 834) | fn write(&mut self, bytes: &[u8]) {
  method finish (line 838) | fn finish(&self) -> u64 {
  function daemonize (line 845) | pub fn daemonize() -> Result<()> {
  function daemonize (line 932) | pub fn daemonize() -> Result<()> {
  function new_reqwest_blocking_client (line 947) | pub fn new_reqwest_blocking_client() -> reqwest::blocking::Client {
  function unhex (line 954) | fn unhex(b: u8) -> std::io::Result<u8> {
  function ascii_unescape_default (line 967) | pub fn ascii_unescape_default(s: &[u8]) -> std::io::Result<Vec<u8>> {
  function num_cpus (line 1015) | pub fn num_cpus() -> usize {
  function strip_basedirs (line 1032) | pub fn strip_basedirs<'a>(preprocessor_output: &'a [u8], basedirs: &[Vec...
  function normalize_win_path (line 1119) | pub fn normalize_win_path(path: &[u8]) -> Vec<u8> {
  function resolve_compiler_avoiding_ccache (line 1191) | pub fn resolve_compiler_avoiding_ccache(
  function test_resolve_compiler_avoiding_ccache_filters_path (line 1256) | fn test_resolve_compiler_avoiding_ccache_filters_path() {
  function test_resolve_compiler_avoiding_ccache_no_path (line 1289) | fn test_resolve_compiler_avoiding_ccache_no_path() {
  function test_resolve_compiler_avoiding_ccache_skips_symlink_to_ccache (line 1304) | fn test_resolve_compiler_avoiding_ccache_skips_symlink_to_ccache() {
  function test_resolve_compiler_avoiding_ccache_absolute_path_unchanged (line 1337) | fn test_resolve_compiler_avoiding_ccache_absolute_path_unchanged() {
  function simple_starts_with (line 1354) | fn simple_starts_with() {
  function simple_strip_prefix (line 1369) | fn simple_strip_prefix() {
  function test_time_macro_short_read (line 1381) | fn test_time_macro_short_read() {
  function test_ascii_unescape_default (line 1460) | fn test_ascii_unescape_default() {
  function test_strip_basedir_simple (line 1502) | fn test_strip_basedir_simple() {
  function test_strip_basedir_empty (line 1524) | fn test_strip_basedir_empty() {
  function test_strip_basedir_not_at_boundary (line 1538) | fn test_strip_basedir_not_at_boundary() {
  function test_strip_basedir_trailing_slashes (line 1549) | fn test_strip_basedir_trailing_slashes() {
  function test_strip_basedirs_multiple (line 1566) | fn test_strip_basedirs_multiple() {
  function test_strip_basedir_windows_backslashes (line 1588) | fn test_strip_basedir_windows_backslashes() {
  function test_strip_basedir_windows_mixed_slashes (line 1607) | fn test_strip_basedir_windows_mixed_slashes() {
  function test_normalize_win_path_ascii (line 1629) | fn test_normalize_win_path_ascii() {
  function test_normalize_win_path_utf8 (line 1642) | fn test_normalize_win_path_utf8() {
  function test_normalize_win_path_mixed_ascii_utf8 (line 1664) | fn test_normalize_win_path_mixed_ascii_utf8() {
  function test_normalize_win_path_invalid_utf8 (line 1673) | fn test_normalize_win_path_invalid_utf8() {
  function test_normalize_win_path_incomplete_utf8 (line 1689) | fn test_normalize_win_path_incomplete_utf8() {
  function test_normalize_win_path_empty (line 1703) | fn test_normalize_win_path_empty() {

FILE: tests/cache_hit_rate.rs
  function test_cache_hit_rate (line 13) | fn test_cache_hit_rate() -> Result<()> {
  function test_adv_cache_hit_rate (line 68) | fn test_adv_cache_hit_rate() -> Result<()> {

FILE: tests/cmake-modules/main.cpp
  function main (line 5) | int main() {

FILE: tests/dist.rs
  function basic_compile (line 26) | fn basic_compile(tmpdir: &Path, sccache_cfg_path: &Path, sccache_cached_...
  function rust_compile (line 56) | fn rust_compile(tmpdir: &Path, sccache_cfg_path: &Path, sccache_cached_c...
  function dist_test_sccache_client_cfg (line 98) | pub fn dist_test_sccache_client_cfg(
  function test_dist_basic (line 110) | fn test_dist_basic() {
  function test_dist_restartedserver (line 143) | fn test_dist_restartedserver() {
  function test_dist_nobuilder (line 179) | fn test_dist_nobuilder() {
  type FailingServer (line 209) | struct FailingServer;
  method handle_assign_job (line 211) | fn handle_assign_job(&self, _job_id: JobId, _tc: Toolchain) -> Result<As...
  method handle_submit_toolchain (line 219) | fn handle_submit_toolchain(
  method handle_run_job (line 227) | fn handle_run_job(
  function test_dist_failingserver (line 244) | fn test_dist_failingserver() {
  function test_dist_cargo_build (line 277) | fn test_dist_cargo_build() {
  function test_dist_cargo_makeflags (line 311) | fn test_dist_cargo_makeflags() {
  function test_dist_preprocesspr_cache_bug_2173 (line 349) | fn test_dist_preprocesspr_cache_bug_2173() {
  function test_dist_toolchain (line 410) | fn test_dist_toolchain() {

FILE: tests/harness/mod.rs
  constant CONTAINER_NAME_PREFIX (line 30) | const CONTAINER_NAME_PREFIX: &str = "sccache_dist_test";
  constant DIST_IMAGE (line 31) | const DIST_IMAGE: &str = "sccache_dist_test_image";
  constant DIST_DOCKERFILE (line 32) | const DIST_DOCKERFILE: &str = include_str!("Dockerfile.sccache-dist");
  constant DIST_IMAGE_BWRAP_PATH (line 33) | const DIST_IMAGE_BWRAP_PATH: &str = "/usr/bin/bwrap";
  constant MAX_STARTUP_WAIT (line 34) | const MAX_STARTUP_WAIT: Duration = Duration::from_secs(5);
  constant DIST_CACHE_RELPATH (line 35) | const DIST_CACHE_RELPATH: &str = "client-dist-cache";
  constant DIST_SERVER_TOKEN (line 37) | const DIST_SERVER_TOKEN: &str = "THIS IS THE TEST TOKEN";
  constant CONFIGS_CONTAINER_PATH (line 39) | const CONFIGS_CONTAINER_PATH: &str = "/sccache-bits";
  constant BUILD_DIR_CONTAINER_PATH (line 40) | const BUILD_DIR_CONTAINER_PATH: &str = "/sccache-bits/build-dir";
  constant SCHEDULER_PORT (line 41) | const SCHEDULER_PORT: u16 = 10500;
  constant SERVER_PORT (line 42) | const SERVER_PORT: u16 = 12345;
  constant TC_CACHE_SIZE (line 44) | const TC_CACHE_SIZE: u64 = 1024 * 1024 * 1024;
  function start_local_daemon (line 46) | pub fn start_local_daemon(cfg_path: &Path, cached_cfg_path: &Path) {
  function stop_local_daemon (line 68) | pub fn stop_local_daemon() -> bool {
  function clear_cache_local_daemon (line 78) | pub fn clear_cache_local_daemon(tmpdir: &Path) -> bool {
  function get_stats (line 85) | pub fn get_stats<F: 'static + Fn(ServerInfo)>(f: F) {
  function zero_stats (line 100) | pub fn zero_stats() {
  function write_json_cfg (line 111) | pub fn write_json_cfg<T: Serialize>(path: &Path, filename: &str, content...
  function write_source (line 117) | pub fn write_source(path: &Path, filename: &str, contents: &str) {
  function init_cargo (line 123) | pub fn init_cargo(path: &Path, cargo_name: &str) -> PathBuf {
  function prune_command (line 131) | pub fn prune_command(mut cmd: Command) -> Command {
  function sccache_command (line 142) | pub fn sccache_command() -> Command {
  function cargo_command (line 146) | pub fn cargo_command() -> Command {
  function sccache_dist_path (line 151) | pub fn sccache_dist_path() -> PathBuf {
  function sccache_client_cfg (line 155) | pub fn sccache_client_cfg(
  function sccache_scheduler_cfg (line 199) | fn sccache_scheduler_cfg() -> sccache::config::scheduler::Config {
  function sccache_server_cfg (line 210) | fn sccache_server_cfg(
  function create_server_token (line 237) | fn create_server_token(server_id: ServerId, auth_token: &str) -> String {
  type ServerHandle (line 243) | pub enum ServerHandle {
  type DistSystem (line 249) | pub struct DistSystem {
    method new (line 260) | pub fn new(sccache_dist: &Path, tmpdir: &Path) -> Self {
    method add_scheduler (line 291) | pub fn add_scheduler(&mut self) {
    method add_server (line 366) | pub fn add_server(&mut self) -> ServerHandle {
    method add_custom_server (line 431) | pub fn add_custom_server<S: dist::ServerIncoming + 'static>(
    method restart_server (line 471) | pub fn restart_server(&mut self, handle: &ServerHandle) {
    method count_toolchains_on_server (line 487) | pub fn count_toolchains_on_server(&mut self, handle: &ServerHandle) ->...
    method wait_server_ready (line 512) | pub fn wait_server_ready(&mut self, handle: &ServerHandle) {
    method scheduler_url (line 540) | pub fn scheduler_url(&self) -> HTTPUrl {
    method scheduler_status (line 545) | fn scheduler_status(&self) -> SchedulerStatusResult {
  method drop (line 558) | fn drop(&mut self) {
  function make_container_name (line 692) | fn make_container_name(tag: &str) -> String {
  function check_output (line 701) | fn check_output(output: &Output) {
  function wait_for_http (line 714) | fn wait_for_http(url: HTTPUrl, interval: Duration, max_wait: Duration) {
  function wait_for (line 730) | fn wait_for<F: Fn() -> Result<(), String>>(f: F, interval: Duration, max...

FILE: tests/helpers/mod.rs
  type SccacheTest (line 40) | pub struct SccacheTest<'a> {
  function new (line 49) | pub fn new(additional_envs: Option<&[(&'static str, std::ffi::OsString)]...
  function show_stats (line 95) | pub fn show_stats(&self) -> assert_cmd::assert::AssertResult {
  function show_text_stats (line 104) | pub fn show_text_stats(&self, advanced: bool) -> assert_cmd::assert::Ass...
  method drop (line 121) | fn drop(&mut self) {
  function stop_sccache (line 126) | pub fn stop_sccache() -> Result<()> {
  function cargo_clean (line 138) | pub fn cargo_clean(test_info: &SccacheTest) -> Result<()> {

FILE: tests/integration/autotools/main.cpp
  function print_hello (line 3) | void print_hello() {

FILE: tests/integration/basedirs-autotools/include/myheader.h
  function std (line 7) | inline std::string get_message() {
  function calculate_sum (line 11) | inline int calculate_sum(int a, int b) {
  function print_header_info (line 15) | inline void print_header_info() {

FILE: tests/integration/basedirs-autotools/main.cpp
  function main (line 4) | int main() {

FILE: tests/integration/cmake-hip/vectoradd_hip.cpp
  function __global__ (line 42) | __global__ void
  function __kernel__ (line 60) | __kernel__ void vectoradd_float(float* a, const float* b, const float* c...
  function main (line 75) | int main() {

FILE: tests/integration/cmake/main.cpp
  function print_hello (line 3) | void print_hello() {

FILE: tests/integration/msvc-preprocessing/foo.cpp
  function main (line 19) | int main() {

FILE: tests/integration/msvc/foo.cpp
  function main (line 3) | int main() {

FILE: tests/integration/randomize_readdir/src/lib.rs
  type Opendir (line 61) | type Opendir = unsafe extern "C" fn(dirname: *const c_char) -> *mut DIR;
  type Fdopendir (line 62) | type Fdopendir = unsafe extern "C" fn(fd: c_int) -> *mut DIR;
  type Readdir (line 63) | type Readdir = unsafe extern "C" fn(dirp: *mut DIR) -> *mut dirent;
  type Readdir64 (line 64) | type Readdir64 = unsafe extern "C" fn(dirp: *mut DIR) -> *mut dirent64;
  type Closedir (line 65) | type Closedir = unsafe extern "C" fn(dirp: *mut DIR) -> c_int;
  type DirentIterator (line 67) | struct DirentIterator<Dirent> {
  type Item (line 73) | type Item = *mut Dirent;
  method next (line 75) | fn next(&mut self) -> Option<Self::Item> {
  type ReaddirState (line 86) | struct ReaddirState {
  type State (line 91) | struct State {
    method new_opendir (line 102) | fn new_opendir(&self, dirp: *mut DIR) {
    method wrapped_readdir_inner (line 112) | fn wrapped_readdir_inner<Dirent, GetIter, Readdir>(
    method wrapped_readdir (line 158) | fn wrapped_readdir(&self, dirp: *mut DIR) -> *mut dirent {
    method wrapped_readdir64 (line 166) | fn wrapped_readdir64(&self, dirp: *mut DIR) -> *mut dirent64 {
  function load_next (line 177) | fn load_next<Prototype: Copy>(name: &[u8]) -> Prototype {
  function init (line 191) | fn init() {
  function opendir (line 227) | pub unsafe extern "C" fn opendir(dirname: *const c_char) -> *mut DIR {
  function fdopendir (line 245) | pub extern "C" fn fdopendir(dirfd: c_int) -> *mut DIR {
  function readdir (line 259) | pub extern "C" fn readdir(dirp: *mut DIR) -> *mut dirent {
  function readdir64 (line 264) | pub extern "C" fn readdir64(dirp: *mut DIR) -> *mut dirent64 {
  function closedir (line 276) | pub unsafe extern "C" fn closedir(dirp: *mut DIR) -> c_int {

FILE: tests/integration/xcode/main.cpp
  function main (line 3) | int main(int argc, const char * argv[]) {

FILE: tests/logging.rs
  function sccache_bin (line 26) | fn sccache_bin() -> PathBuf {
  function test_log_timestamp_format_without_millis (line 32) | fn test_log_timestamp_format_without_millis() {
  function test_log_timestamp_format_with_millis (line 66) | fn test_log_timestamp_format_with_millis() {
  function test_log_millis_flag_with_various_values (line 93) | fn test_log_millis_flag_with_various_values() {

FILE: tests/msvc-msbuild/test_bar.cpp
  function bar (line 1) | int bar(int x) { return x; }

FILE: tests/msvc-msbuild/test_baz.cpp
  function baz (line 1) | int baz(int x) { return x; }

FILE: tests/msvc-msbuild/test_foo.cpp
  function foo (line 1) | int foo(int x) { return x; }

FILE: tests/oauth.rs
  constant LOCAL_AUTH_BASE_URL (line 12) | const LOCAL_AUTH_BASE_URL: &str = "http://localhost:12731/";
  constant USERNAME_SELECTOR (line 14) | const USERNAME_SELECTOR: &str = ".auth0-lock-input-email .auth0-lock-inp...
  constant PASSWORD_SELECTOR (line 15) | const PASSWORD_SELECTOR: &str = ".auth0-lock-input-password .auth0-lock-...
  constant LOGIN_SELECTOR (line 16) | const LOGIN_SELECTOR: &str = ".auth0-lock-submit";
  constant BROWSER_RETRY_WAIT (line 18) | const BROWSER_RETRY_WAIT: Duration = Duration::from_secs(1);
  constant BROWSER_MAX_WAIT (line 19) | const BROWSER_MAX_WAIT: Duration = Duration::from_secs(10);
  constant TEST_USERNAME (line 26) | const TEST_USERNAME: &str = "test@example.com";
  constant TEST_PASSWORD (line 27) | const TEST_PASSWORD: &str = "test1234";
  function generate_code_grant_pkce_auth_config (line 29) | fn generate_code_grant_pkce_auth_config() -> sccache::config::DistAuth {
  function generate_implicit_auth_config (line 38) | fn generate_implicit_auth_config() -> sccache::config::DistAuth {
  function config_with_dist_auth (line 47) | fn config_with_dist_auth(
  function sccache_command (line 66) | fn sccache_command() -> Command {
  function retry (line 70) | fn retry<F: FnMut() -> Option<T>, T>(interval: Duration, until: Duration...
  type DriverExt (line 82) | trait DriverExt {
    method wait_for_element (line 83) | async fn wait_for_element(&self, selector: &str) -> WebDriverResult<()>;
    method wait_on_url (line 84) | async fn wait_on_url<F: Fn(&str) -> bool>(&self, condition: F) -> WebD...
    method wait_for_element (line 87) | async fn wait_for_element(&self, selector: &str) -> WebDriverResult<()> {
    method wait_on_url (line 94) | async fn wait_on_url<F: Fn(&str) -> bool>(&self, condition: F) -> WebD...
  function auth0_login (line 107) | async fn auth0_login(driver: &WebDriver, email: &str, password: &str) {
  type SeleniumContainer (line 133) | struct SeleniumContainer {
    method new (line 149) | fn new() -> Self {
  function check_output (line 137) | fn check_output(output: &Output) {
  method drop (line 175) | fn drop(&mut self) {
  function test_auth (line 199) | async fn test_auth() {
  function test_auth_with_config (line 228) | async fn test_auth_with_config(dist_auth: sccache::config::DistAuth) {
  function login (line 281) | async fn login() {

FILE: tests/sccache_args.rs
  function test_gcp_arg_check (line 20) | fn test_gcp_arg_check() -> Result<()> {
  function test_s3_invalid_args (line 63) | fn test_s3_invalid_args() -> Result<()> {

FILE: tests/sccache_cargo.rs
  function test_rust_cargo_check (line 24) | fn test_rust_cargo_check() -> Result<()> {
  function test_rust_cargo_check_readonly (line 30) | fn test_rust_cargo_check_readonly() -> Result<()> {
  function test_rust_cargo_build (line 36) | fn test_rust_cargo_build() -> Result<()> {
  function test_rust_cargo_build_readonly (line 42) | fn test_rust_cargo_build_readonly() -> Result<()> {
  function test_run_log_no_perm (line 49) | fn test_run_log_no_perm() -> Result<()> {
  function test_run_log (line 65) | fn test_run_log() -> Result<()> {
  function test_rust_cargo_run_with_env_dep_parsing (line 89) | fn test_rust_cargo_run_with_env_dep_parsing() -> Result<()> {
  function test_rust_cargo_check_nightly (line 96) | fn test_rust_cargo_check_nightly() -> Result<()> {
  function test_rust_cargo_check_nightly_readonly (line 111) | fn test_rust_cargo_check_nightly_readonly() -> Result<()> {
  function test_rust_cargo_build_nightly (line 126) | fn test_rust_cargo_build_nightly() -> Result<()> {
  function test_rust_cargo_build_nightly_readonly (line 141) | fn test_rust_cargo_build_nightly_readonly() -> Result<()> {
  function test_rust_cargo_cmd (line 156) | fn test_rust_cargo_cmd(cmd: &str, test_info: SccacheTest) -> Result<()> {
  function restart_sccache (line 191) | fn restart_sccache(
  function test_rust_cargo_cmd_readonly (line 222) | fn test_rust_cargo_cmd_readonly(cmd: &str, test_info: SccacheTest) -> Re...
  function test_rust_cargo_env_dep (line 312) | fn test_rust_cargo_env_dep(test_info: SccacheTest) -> Result<()> {
  function test_rust_cargo_cmd_readonly_preemtive_block (line 352) | fn test_rust_cargo_cmd_readonly_preemtive_block() -> Result<()> {

FILE: tests/sccache_rustc.rs
  type StopServer (line 18) | struct StopServer;
  method drop (line 20) | fn drop(&mut self) {
  function test_symlinks (line 46) | fn test_symlinks() {
  function create_mock_rustc (line 74) | fn create_mock_rustc(dir: PathBuf) {
  function run_sccache (line 140) | fn run_sccache(root: &Path, path: &Path) {

FILE: tests/system.rs
  type Compiler (line 50) | struct Compiler {
  constant COMPILERS (line 58) | const COMPILERS: &[&str] = &["gcc", "clang", "clang++", "nvc", "nvc++"];
  constant COMPILERS (line 62) | const COMPILERS: &[&str] = &["clang", "clang++"];
  constant CUDA_COMPILERS (line 64) | const CUDA_COMPILERS: &[&str] = &["nvcc", "clang++"];
  function adv_key_kind (line 66) | fn adv_key_kind(lang: &str, compiler: &str) -> String {
  function compile_cmdline (line 96) | fn compile_cmdline<T: AsRef<OsStr>>(
  function compile_cuda_cmdline (line 118) | fn compile_cuda_cmdline<T: AsRef<OsStr>>(
  function compile_hip_cmdline (line 161) | fn compile_hip_cmdline<T: AsRef<OsStr>>(
  constant INPUT (line 184) | const INPUT: &str = "test.c";
  constant INPUT_CLANG_MULTICALL (line 185) | const INPUT_CLANG_MULTICALL: &str = "test_clang_multicall.c";
  constant INPUT_WITH_WHITESPACE (line 186) | const INPUT_WITH_WHITESPACE: &str = "test_whitespace.c";
  constant INPUT_WITH_WHITESPACE_ALT (line 187) | const INPUT_WITH_WHITESPACE_ALT: &str = "test_whitespace_alt.c";
  constant INPUT_ERR (line 188) | const INPUT_ERR: &str = "test_err.c";
  constant INPUT_MACRO_EXPANSION (line 189) | const INPUT_MACRO_EXPANSION: &str = "test_macro_expansion.c";
  constant INPUT_WITH_DEFINE (line 190) | const INPUT_WITH_DEFINE: &str = "test_with_define.c";
  constant INPUT_FOR_CUDA_A (line 191) | const INPUT_FOR_CUDA_A: &str = "test_a.cu";
  constant INPUT_FOR_CUDA_B (line 192) | const INPUT_FOR_CUDA_B: &str = "test_b.cu";
  constant INPUT_FOR_CUDA_C (line 193) | const INPUT_FOR_CUDA_C: &str = "test_c.cu";
  constant INPUT_FOR_HIP_A (line 194) | const INPUT_FOR_HIP_A: &str = "test_a.hip";
  constant INPUT_FOR_HIP_B (line 195) | const INPUT_FOR_HIP_B: &str = "test_b.hip";
  constant INPUT_FOR_HIP_C (line 196) | const INPUT_FOR_HIP_C: &str = "test_c.hip";
  constant OUTPUT (line 197) | const OUTPUT: &str = "test.o";
  function copy_to_tempdir (line 200) | fn copy_to_tempdir(inputs: &[&str], tempdir: &Path) {
  function test_basic_compile (line 216) | fn test_basic_compile(compiler: Compiler, tempdir: &Path) {
  function test_noncacheable_stats (line 268) | fn test_noncacheable_stats(compiler: Compiler, tempdir: &Path) {
  function test_msvc_deps (line 295) | fn test_msvc_deps(compiler: Compiler, tempdir: &Path) {
  function test_msvc_responsefile (line 326) | fn test_msvc_responsefile(compiler: Compiler, tempdir: &Path) {
  function test_gcc_mp_werror (line 353) | fn test_gcc_mp_werror(compiler: Compiler, tempdir: &Path) {
  function test_gcc_fprofile_generate_source_changes (line 378) | fn test_gcc_fprofile_generate_source_changes(compiler: Compiler, tempdir...
  function test_split_dwarf_object_generate_output_dir_changes (line 468) | fn test_split_dwarf_object_generate_output_dir_changes(compiler: Compile...
  function test_gcc_clang_no_warnings_from_macro_expansion (line 527) | fn test_gcc_clang_no_warnings_from_macro_expansion(compiler: Compiler, t...
  function test_compile_with_define (line 553) | fn test_compile_with_define(compiler: Compiler, tempdir: &Path) {
  function test_gcc_clang_depfile (line 579) | fn test_gcc_clang_depfile(compiler: Compiler, tempdir: &Path) {
  function run_sccache_command_tests (line 629) | fn run_sccache_command_tests(compiler: Compiler, tempdir: &Path, preproc...
  function test_nvcc_cuda_compiles (line 692) | fn test_nvcc_cuda_compiles(compiler: &Compiler, tempdir: &Path) {
  function test_nvcc_proper_lang_stat_tracking (line 1170) | fn test_nvcc_proper_lang_stat_tracking(compiler: Compiler, tempdir: &Pat...
  function run_sccache_nvcc_cuda_command_tests (line 1248) | fn run_sccache_nvcc_cuda_command_tests(compiler: Compiler, tempdir: &Pat...
  function test_clang_cuda_compiles (line 1253) | fn test_clang_cuda_compiles(compiler: &Compiler, tempdir: &Path) {
  function test_clang_proper_lang_stat_tracking (line 1348) | fn test_clang_proper_lang_stat_tracking(compiler: Compiler, tempdir: &Pa...
  function run_sccache_clang_cuda_command_tests (line 1421) | fn run_sccache_clang_cuda_command_tests(compiler: Compiler, tempdir: &Pa...
  function test_hip_compiles (line 1426) | fn test_hip_compiles(compiler: &Compiler, tempdir: &Path) {
  function test_hip_compiles_multi_targets (line 1523) | fn test_hip_compiles_multi_targets(compiler: &Compiler, tempdir: &Path) {
  function run_sccache_hip_command_tests (line 1622) | fn run_sccache_hip_command_tests(compiler: Compiler, tempdir: &Path) {
  function test_clang_multicall (line 1630) | fn test_clang_multicall(compiler: Compiler, tempdir: &Path) {
  function test_clang_cache_whitespace_normalization (line 1655) | fn test_clang_cache_whitespace_normalization(
  function find_compilers (line 1732) | fn find_compilers() -> Vec<Compiler> {
  function find_compilers (line 1749) | fn find_compilers() -> Vec<Compiler> {
  function find_cuda_compilers (line 1763) | fn find_cuda_compilers() -> Vec<Compiler> {
  function find_hip_compiler (line 1810) | fn find_hip_compiler() -> Option<Compiler> {
  function test_sccache_command (line 1846) | fn test_sccache_command(preprocessor_cache_mode: bool) {
  function test_stats_no_server (line 1878) | fn test_stats_no_server() {
  function test_cuda_sccache_command (line 1892) | fn test_cuda_sccache_command(preprocessor_cache_mode: bool) {
  function test_hip_sccache_command (line 1937) | fn test_hip_sccache_command(preprocessor_cache_mode: bool) {
  function test_symlinked_exe (line 1966) | fn test_symlinked_exe() {

FILE: tests/test-crate/src/bin.rs
  function main (line 3) | fn main() {

FILE: tests/test-crate/src/lib.rs
  function unused (line 1) | fn unused() {}
  function env_dep_test (line 3) | pub fn env_dep_test() {
  function it_works (line 10) | fn it_works() {

FILE: tests/test.c
  function foo (line 3) | void foo() {

FILE: tests/test_clang_multicall.c
  function main (line 6) | int main() {

FILE: tests/test_macro_expansion.c
  function bar (line 10) | void bar() { foo(0); }

FILE: tests/test_whitespace.c
  function main (line 3) | int main() {printf("Hello world!");return 0;}

FILE: tests/test_whitespace_alt.c
  function main (line 3) | int main()

FILE: tests/test_with_define.c
  function foo (line 7) | void foo() { printf("hello world\n"); }

[
  {
    "path": ".envrc",
    "chars": 284,
    "preview": "if has nix; then\n  if ! has nix_direnv_version || ! nix_direnv_version 3.1.0; then\n    source_url \"https://raw.githubuse"
  },
  {
    "path": ".github/actions/artifact_failure/action.yml",
    "chars": 922,
    "preview": "name: \"Upload failure Artifacts\"\ndescription: \"Upload failure Artifacts\"\ninputs:\n  name:\n    description: \"\"\n    require"
  },
  {
    "path": ".github/actions/nvcc-toolchain/action.yml",
    "chars": 430,
    "preview": "name: nvcc-toolchain\ninputs:\n  cuda-version:\n    description: CUDA Toolkit version\n    required: true\n\nruns:\n  using: co"
  },
  {
    "path": ".github/actions/nvcc-toolchain/install-cuda.ps1",
    "chars": 2027,
    "preview": "Param(\n    [Parameter(Mandatory=$false)]\n    [string]\n    $cudaVersion=\"12.8.0\"\n)\n\n# Use System.Version to tokenize vers"
  },
  {
    "path": ".github/actions/nvcc-toolchain/install-cuda.sh",
    "chars": 1658,
    "preview": "#! /usr/bin/env bash\nset -eu\n\nexport DEBIAN_FRONTEND=noninteractive\n\nget_cuda_deb() {\n    local deb=\"$(                 "
  },
  {
    "path": ".github/actions/rust-toolchain/action.yml",
    "chars": 790,
    "preview": "name: rust-toolchain\ninputs:\n  toolchain:\n    description: |\n      Rust toolchain name.\n      See https://rust-lang.gith"
  },
  {
    "path": ".github/codecov.yml",
    "chars": 75,
    "preview": "coverage:\r\n  status:\r\n    project:\r\n      default:\r\n        threshold: 0.2%"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 268,
    "preview": "version: 2\nupdates:\n  - package-ecosystem: \"cargo\"\n    directory: \"/\"\n    schedule:\n      interval: weekly \n    open-pul"
  },
  {
    "path": ".github/workflows/benchmarks.yml",
    "chars": 1191,
    "preview": "name: Benchmarks\n\n# spell-checker:ignore codspeed dtolnay Swatinem\n\non:\n  pull_request:\n  push:\n    branches:\n      - '*"
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 18143,
    "preview": "name: ci\non: [ push, pull_request ]\n\njobs:\n  lint:\n    name: ${{ matrix.component }} ${{ matrix.os }}\n    runs-on: ${{ m"
  },
  {
    "path": ".github/workflows/close-snap.yml",
    "chars": 372,
    "preview": "name: Close Snaps\n\non:\n  pull_request:\n    types: [closed]\n\njobs:\n  close:\n    runs-on: ubuntu-latest\n\n    timeout-minut"
  },
  {
    "path": ".github/workflows/integration-tests.yml",
    "chars": 12256,
    "preview": "name: integration-tests\non: [ push, pull_request ]\n\nenv:\n  RUST_BACKTRACE: full\n  RUST_LOG: debug\n  SCCACHE_PATH: /home/"
  },
  {
    "path": ".github/workflows/snap.yml",
    "chars": 717,
    "preview": "name: Snap\n\non:\n  pull_request:\n    types: [opened, synchronize, reopened, ready_for_review]\n\njobs:\n  Snap:\n    runs-on:"
  },
  {
    "path": ".gitignore",
    "chars": 267,
    "preview": "target\n*~\n\n*.log\n.cargo\n*.pyc\n\n# snapcraft artifacts\n/parts\n/prime\n/snap/.snapcraft\n/stage\n/*.snap\n\n# Ignore lockfiles o"
  },
  {
    "path": ".pre-commit-config.yaml",
    "chars": 558,
    "preview": "repos:\n-   repo: local\n    hooks:\n    -   id: rust-linting\n        name: Rust linting\n        description: Run cargo fmt"
  },
  {
    "path": ".rustfmt.toml",
    "chars": 64,
    "preview": "# Should match package.edition from Cargo.toml\nedition = \"2024\"\n"
  },
  {
    "path": ".taplo.toml",
    "chars": 1424,
    "preview": "include = [\"Cargo.toml\", \"**/*.toml\"]\n\n[formatting]\n# Align consecutive entries vertically.\nalign_entries = false\n# Appe"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 691,
    "preview": "# Community Participation Guidelines\n\nThis repository is governed by Mozilla's code of conduct and etiquette guidelines."
  },
  {
    "path": "Cargo.toml",
    "chars": 5921,
    "preview": "[package]\n# Should match .rustfmt.toml\nedition = \"2024\"\nname = \"sccache\"\nrust-version = \"1.85.0\"\nversion = \"0.14.0\"\n\ncat"
  },
  {
    "path": "LICENSE",
    "chars": 11358,
    "preview": "\n                                 Apache License\n                           Version 2.0, January 2004\n                  "
  },
  {
    "path": "README.md",
    "chars": 18438,
    "preview": "[![Build Status](https://github.com/mozilla/sccache/workflows/ci/badge.svg)](https://github.com/mozilla/sccache/actions?"
  },
  {
    "path": "benches/sccache_bench.rs",
    "chars": 30200,
    "preview": "// Copyright 2025 Mozilla\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this "
  },
  {
    "path": "docs/Architecture.md",
    "chars": 540,
    "preview": "# Sccache high level architecture\n\nThis schema shows at high level how sccache works.\n\n\n```mermaid\n  flowchart LR\n      "
  },
  {
    "path": "docs/Azure.md",
    "chars": 791,
    "preview": "# Azure\n\nTo use Azure Blob Storage, you'll need your Azure connection string and an _existing_ Blob Storage container na"
  },
  {
    "path": "docs/COS.md",
    "chars": 944,
    "preview": "# COS\n\nIf you want to use _Tencent Cloud Object Storage_ (aka COS) for the sccache cache, you need to set the `SCCACHE_C"
  },
  {
    "path": "docs/Caching.md",
    "chars": 2300,
    "preview": "# How caching works\n\nTo know if the storage contains the artifact we need, we are\ncomputing some hashes to make sure the"
  },
  {
    "path": "docs/Configuration.md",
    "chars": 10750,
    "preview": "# Available Configuration Options\n\n## file\n\n```toml\n# If specified, wait this long for the server to start up.\nserver_st"
  },
  {
    "path": "docs/Distributed.md",
    "chars": 13996,
    "preview": "# Distributed sccache\n\nBackground:\n\n - You should read about JSON Web Tokens - https://jwt.io/.\n   - HS256 in short: you"
  },
  {
    "path": "docs/DistributedFreeBSD.md",
    "chars": 4044,
    "preview": "Distributed sccache on FreeBSD\n==============================\n\nPlease read the [the distributed quickstart](DistributedQ"
  },
  {
    "path": "docs/DistributedQuickstart.md",
    "chars": 11320,
    "preview": "sccache distributed compilation quickstart\n==========================================\n\nThis is a quick start guide to ge"
  },
  {
    "path": "docs/GHA.md",
    "chars": 877,
    "preview": "# GitHub Actions\n\nTo use the [GitHub Actions cache](https://docs.github.com/en/actions/using-workflows/caching-dependenc"
  },
  {
    "path": "docs/Gcs.md",
    "chars": 3126,
    "preview": "# Google Cloud Storage\n\nTo use [Google Cloud Storage](https://cloud.google.com/storage/), you need to set\nthe `SCCACHE_G"
  },
  {
    "path": "docs/Jenkins.md",
    "chars": 1516,
    "preview": "sccache on Jenkins\n==================\n\nWhen using `sccache` on [Jenkins](https://jenkins.io) one has to know about how t"
  },
  {
    "path": "docs/Local.md",
    "chars": 4554,
    "preview": "# Local\n\nsccache defaults to using local disk storage. You can set the `SCCACHE_DIR` environment variable to change the "
  },
  {
    "path": "docs/Memcached.md",
    "chars": 869,
    "preview": "# Memcached\n\nSet `SCCACHE_MEMCACHED_ENDPOINT` to a [Memcached](https://memcached.org/) url in format `tcp://<hostname>:<"
  },
  {
    "path": "docs/OSS.md",
    "chars": 1229,
    "preview": "# OSS\n\nIf you want to use _Object Storage Service_ (aka OSS) by Alibaba for the sccache cache, you need to set the `SCCA"
  },
  {
    "path": "docs/Redis.md",
    "chars": 2794,
    "preview": "# Redis\n\nIf you want to use [Redis](https://redis.io/) storage for the sccache cache, you need to set the `SCCACHE_REDIS"
  },
  {
    "path": "docs/Releasing.md",
    "chars": 1149,
    "preview": "# Sccache Release Process\n\nMost of the sccache release process is automated. The [github workflow](https://github.com/mo"
  },
  {
    "path": "docs/ResponseFiles.md",
    "chars": 3673,
    "preview": "# Response Files\n\nResponse files are a way for compilers to accept arguments that would otherwise overflow the character"
  },
  {
    "path": "docs/Rust.md",
    "chars": 792,
    "preview": "sccache includes support for caching Rust compilation. This includes many caveats, and is primarily focused on caching r"
  },
  {
    "path": "docs/S3.md",
    "chars": 3456,
    "preview": "# S3\n\nIf you want to use S3 storage for the sccache cache, you need to set the following environment variables:\n\n- `SCCA"
  },
  {
    "path": "docs/Webdav.md",
    "chars": 884,
    "preview": "# WebDAV\n\nUsers can configure sccache to cache incremental build artifacts in a remote WebDAV service.\nThe following ser"
  },
  {
    "path": "docs/Xcode.md",
    "chars": 3257,
    "preview": "# Using `sccache` with Xcode\n\nIt is possible to use `sccache` with Xcode with some setup.\n\n### Running the daemon\nBefore"
  },
  {
    "path": "flake.nix",
    "chars": 2442,
    "preview": "{\n  description = \"sccache development environment and package\";\n\n  inputs = {\n    nixpkgs.url = \"github:NixOS/nixpkgs/n"
  },
  {
    "path": "scripts/extratest.sh",
    "chars": 4750,
    "preview": "#!/bin/sh\nset -o errexit\nset -o pipefail\nset -o nounset\nset -o xtrace\n\n#CARGO=\"cargo --color=always\"\nCARGO=\"cargo\"\n\ngnut"
  },
  {
    "path": "scripts/freebsd-ci-test.sh",
    "chars": 9443,
    "preview": "#!/bin/sh\n\n# This script contains CI tests for FreeBSD, testing\n#\n# - cargo build & cargo test\n# - configure and start s"
  },
  {
    "path": "snap/snapcraft.yaml",
    "chars": 1571,
    "preview": "name: sccache\nbase: core24\nadopt-info: sccache\n\nsummary: sccache is ccache with cloud storage\ndescription: |\n  sccache i"
  },
  {
    "path": "src/bin/sccache-dist/build.rs",
    "chars": 34878,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/bin/sccache-dist/build_freebsd.rs",
    "chars": 15821,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/bin/sccache-dist/cmdline/mod.rs",
    "chars": 1064,
    "preview": "// Copyright 2022 <LovecraftianHorror@pm.me>\n// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache Licens"
  },
  {
    "path": "src/bin/sccache-dist/cmdline/parse.rs",
    "chars": 13237,
    "preview": "// Copyright 2022 <LovecraftianHorror@pm.me>\n// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache Licens"
  },
  {
    "path": "src/bin/sccache-dist/main.rs",
    "chars": 31618,
    "preview": "#[macro_use]\nextern crate log;\n\nuse anyhow::{Context, Result, bail};\nuse base64::Engine;\nuse rand::{RngCore, rngs::OsRng"
  },
  {
    "path": "src/bin/sccache-dist/token_check.rs",
    "chars": 6954,
    "preview": "use anyhow::{Context, Result, bail};\nuse base64::Engine;\nuse sccache::dist::http::{ClientAuthCheck, ClientVisibleMsg};\nu"
  },
  {
    "path": "src/cache/azure.rs",
    "chars": 1281,
    "preview": "// Copyright 2018 Benjamin Bader\n// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2"
  },
  {
    "path": "src/cache/cache.rs",
    "chars": 21513,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/cache/cache_io.rs",
    "chars": 8885,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/cache/cos.rs",
    "chars": 1274,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/cache/disk.rs",
    "chars": 6859,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/cache/gcs.rs",
    "chars": 4164,
    "preview": "// Copyright 2017 Mozilla Foundation\n// Copyright 2017 Google Inc.\n//\n// Licensed under the Apache License, Version 2.0 "
  },
  {
    "path": "src/cache/gha.rs",
    "chars": 1660,
    "preview": "// Copyright 2022 Bitski Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use t"
  },
  {
    "path": "src/cache/http_client.rs",
    "chars": 365,
    "preview": "use opendal::raw::HttpClient;\nuse reqwest::ClientBuilder;\n\n/// Set the user agent (helps with monitoring on the server s"
  },
  {
    "path": "src/cache/lazy_disk_cache.rs",
    "chars": 1691,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/cache/memcached.rs",
    "chars": 1563,
    "preview": "// Copyright 2016 Mozilla Foundation\n// Copyright 2017 David Michael Barr <b@rr-dav.id.au>\n//\n// Licensed under the Apac"
  },
  {
    "path": "src/cache/mod.rs",
    "chars": 1439,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/cache/oss.rs",
    "chars": 1566,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/cache/readonly.rs",
    "chars": 7101,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/cache/redis.rs",
    "chars": 3295,
    "preview": "// Copyright 2016 Mozilla Foundation\n// Copyright 2016 Felix Obenhuber <felix@obenhuber.de>\n//\n// Licensed under the Apa"
  },
  {
    "path": "src/cache/s3.rs",
    "chars": 6579,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/cache/utils.rs",
    "chars": 1764,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/cache/webdav.rs",
    "chars": 1486,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/client.rs",
    "chars": 3547,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/cmdline.rs",
    "chars": 13163,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/commands.rs",
    "chars": 30137,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/args.rs",
    "chars": 39574,
    "preview": "use std::cmp::Ordering;\nuse std::error::Error;\nuse std::ffi::OsString;\nuse std::fmt::{self, Debug, Display};\nuse std::ma"
  },
  {
    "path": "src/compiler/c.rs",
    "chars": 78325,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/cicc.rs",
    "chars": 11529,
    "preview": "// Copyright 2016 Mozilla Foundation\n// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All "
  },
  {
    "path": "src/compiler/clang.rs",
    "chars": 42777,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/compiler.rs",
    "chars": 130971,
    "preview": "// Copyright 2016 Mozilla Foundation\n// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All "
  },
  {
    "path": "src/compiler/counted_array.rs",
    "chars": 822,
    "preview": "/// Helper macro to create fixed-length arrays without specifying a fixed size\n#[macro_export]\nmacro_rules! counted_arra"
  },
  {
    "path": "src/compiler/cudafe.rs",
    "chars": 6054,
    "preview": "// Copyright 2016 Mozilla Foundation\n// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All "
  },
  {
    "path": "src/compiler/diab.rs",
    "chars": 26614,
    "preview": "// Copyright 2018 Mozilla Foundation\n// Copyright 2018 Felix Obenhuber <felix@obenhuber.de>\n//\n// Licensed under the Apa"
  },
  {
    "path": "src/compiler/gcc.rs",
    "chars": 92612,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/mod.rs",
    "chars": 1015,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/msvc.rs",
    "chars": 106937,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/nvcc.rs",
    "chars": 75144,
    "preview": "// Copyright 2016 Mozilla Foundation\n// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All "
  },
  {
    "path": "src/compiler/nvhpc.rs",
    "chars": 13579,
    "preview": "// Copyright 2016 Mozilla Foundation\n// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All "
  },
  {
    "path": "src/compiler/preprocessor_cache.rs",
    "chars": 30396,
    "preview": "// Copyright 2023 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/ptxas.rs",
    "chars": 3413,
    "preview": "// Copyright 2016 Mozilla Foundation\n// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All "
  },
  {
    "path": "src/compiler/rust.rs",
    "chars": 136304,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/compiler/tasking_vx.rs",
    "chars": 26433,
    "preview": "// Copyright 2018 Mozilla Foundation\n// Copyright 2019 ESRLabs AG\n//\n// Licensed under the Apache License, Version 2.0 ("
  },
  {
    "path": "src/config.rs",
    "chars": 79915,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/dist/cache.rs",
    "chars": 21258,
    "preview": "use crate::dist::Toolchain;\nuse crate::lru_disk_cache::Result as LruResult;\nuse crate::lru_disk_cache::{LruDiskCache, Re"
  },
  {
    "path": "src/dist/client_auth.rs",
    "chars": 23178,
    "preview": "use bytes::Bytes;\nuse futures::channel::oneshot;\nuse http::StatusCode;\nuse http::header::{CONTENT_LENGTH, CONTENT_TYPE};"
  },
  {
    "path": "src/dist/http.rs",
    "chars": 54689,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/dist/mod.rs",
    "chars": 23046,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/dist/pkg.rs",
    "chars": 19675,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/dist/test.rs",
    "chars": 1,
    "preview": "\n"
  },
  {
    "path": "src/errors.rs",
    "chars": 2041,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/jobserver.rs",
    "chars": 5512,
    "preview": "use std::io;\nuse std::process::Command;\nuse std::sync::Arc;\n\nuse futures::StreamExt;\nuse futures::channel::mpsc;\nuse fut"
  },
  {
    "path": "src/lib.rs",
    "chars": 2935,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/lru_disk_cache/lru_cache.rs",
    "chars": 25634,
    "preview": "// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution"
  },
  {
    "path": "src/lru_disk_cache/mod.rs",
    "chars": 25946,
    "preview": "pub mod lru_cache;\n\nuse fs::File;\nuse fs_err as fs;\nuse std::borrow::Borrow;\nuse std::boxed::Box;\nuse std::collections::"
  },
  {
    "path": "src/main.rs",
    "chars": 654,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/mock_command.rs",
    "chars": 21486,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/net.rs",
    "chars": 6303,
    "preview": "// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance wit"
  },
  {
    "path": "src/protocol.rs",
    "chars": 2575,
    "preview": "use crate::compiler::ColorMode;\nuse crate::server::{DistInfo, ServerInfo};\nuse serde::{Deserialize, Serialize};\nuse std:"
  },
  {
    "path": "src/server.rs",
    "chars": 86634,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/test/mock_storage.rs",
    "chars": 2755,
    "preview": "// Copyright 2017 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/test/mod.rs",
    "chars": 657,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/test/tests.rs",
    "chars": 11117,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/test/utils.rs",
    "chars": 7996,
    "preview": "// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "src/util.rs",
    "chars": 61067,
    "preview": "// Copyright 2017 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "tests/cache_hit_rate.rs",
    "chars": 3323,
    "preview": "pub mod helpers;\n\nuse std::process::Command;\n\nuse anyhow::Result;\nuse assert_cmd::assert::OutputAssertExt;\nuse helpers::"
  },
  {
    "path": "tests/cmake-modules/CMakeLists.txt",
    "chars": 393,
    "preview": "cmake_minimum_required(VERSION 3.28)\n\nproject(myproject LANGUAGES CXX)\n\nset(CMAKE_CXX_STANDARD 20)\nset(CMAKE_CXX_STANDAR"
  },
  {
    "path": "tests/cmake-modules/main.cpp",
    "chars": 135,
    "preview": "#include <stdio.h>\n\nimport mymodule;\n\nint main() {\n    print_hello_world();\n    printf(\"add(1, 2) = %d\\n\", add(1, 2));\n "
  },
  {
    "path": "tests/cmake-modules/mymodule.cppm",
    "chars": 190,
    "preview": "module;\n\n#include <iostream>\n\nexport module mymodule;\n\nexport void print_hello_world() {\n    std::cout << \"Hello, World!"
  },
  {
    "path": "tests/dist.rs",
    "chars": 16038,
    "preview": "#![cfg(all(feature = \"dist-client\", feature = \"dist-server\"))]\n\nextern crate assert_cmd;\nextern crate log;\nextern crate "
  },
  {
    "path": "tests/harness/Dockerfile.sccache-dist",
    "chars": 108,
    "preview": "FROM ubuntu:latest\nRUN apt-get update && \\\n    apt-get install -y libcap2 bubblewrap && \\\n    apt-get clean\n"
  },
  {
    "path": "tests/harness/mod.rs",
    "chars": 24499,
    "preview": "use fs_err as fs;\nuse log::trace;\n#[cfg(any(feature = \"dist-client\", feature = \"dist-server\"))]\nuse sccache::config::HTT"
  },
  {
    "path": "tests/helpers/mod.rs",
    "chars": 4737,
    "preview": "#![allow(clippy::result_large_err)]\n\nuse anyhow::{Context, Result};\nuse assert_cmd::assert::OutputAssertExt;\nuse chrono:"
  },
  {
    "path": "tests/integration/Makefile",
    "chars": 7520,
    "preview": ".PHONY: help clean $(addprefix test-,$(BACKENDS)) $(addprefix clean-,$(BACKENDS)) test-backends\n\nexport UID := $(shell i"
  },
  {
    "path": "tests/integration/README.md",
    "chars": 1272,
    "preview": "# sccache Integration Tests\n\nDocker Compose-based integration tests for sccache backends and compilers.\n\n## Prerequisite"
  },
  {
    "path": "tests/integration/autotools/Makefile.am",
    "chars": 68,
    "preview": "noinst_LIBRARIES = libmyproject.a\nlibmyproject_a_SOURCES = main.cpp\n"
  },
  {
    "path": "tests/integration/autotools/configure.ac",
    "chars": 197,
    "preview": "AC_INIT([myproject], [1.0])\nAM_INIT_AUTOMAKE([foreign subdir-objects])\nAC_CONFIG_SRCDIR([main.cpp])\nAC_CONFIG_HEADERS([c"
  },
  {
    "path": "tests/integration/autotools/main.cpp",
    "chars": 91,
    "preview": "#include <iostream>\n\nvoid print_hello() {\n    std::cout << \"Hello, World!\" << std::endl;\n}\n"
  },
  {
    "path": "tests/integration/basedirs-autotools/Makefile.am",
    "chars": 342,
    "preview": "noinst_LIBRARIES = libbasedirs.a\n# Use absolute path for source file - autoconf will substitute abs_srcdir and abs_build"
  },
  {
    "path": "tests/integration/basedirs-autotools/configure.ac",
    "chars": 312,
    "preview": "AC_INIT([basedirs-test], [1.0])\nAM_INIT_AUTOMAKE([foreign subdir-objects])\nAC_CONFIG_SRCDIR([main.cpp])\nAC_CONFIG_HEADER"
  },
  {
    "path": "tests/integration/basedirs-autotools/include/myheader.h",
    "chars": 333,
    "preview": "#ifndef MYHEADER_H\n#define MYHEADER_H\n\n#include <string>\n#include <iostream>\n\ninline std::string get_message() {\n    ret"
  },
  {
    "path": "tests/integration/basedirs-autotools/main.cpp",
    "chars": 261,
    "preview": "#include <iostream>\n#include \"myheader.h\"\n\nint main() {\n    std::cout << \"Main file: \" << __FILE__ << std::endl;\n    std"
  },
  {
    "path": "tests/integration/cmake/CMakeLists.txt",
    "chars": 111,
    "preview": "cmake_minimum_required(VERSION 3.10)\n\nproject(myproject LANGUAGES CXX)\n\nadd_library(myproject OBJECT main.cpp)\n"
  },
  {
    "path": "tests/integration/cmake/main.cpp",
    "chars": 91,
    "preview": "#include <iostream>\n\nvoid print_hello() {\n    std::cout << \"Hello, World!\" << std::endl;\n}\n"
  },
  {
    "path": "tests/integration/cmake-hip/CMakeLists.txt",
    "chars": 192,
    "preview": "cmake_minimum_required(VERSION 3.10)\n\nproject(myproject LANGUAGES CXX HIP)\n\nadd_library(vectoradd_hip vectoradd_hip.cpp)"
  },
  {
    "path": "tests/integration/cmake-hip/vectoradd_hip.cpp",
    "chars": 4015,
    "preview": "/*\nCopyright (c) 2015-2016 Advanced Micro Devices, Inc. All rights reserved.\n\nPermission is hereby granted, free of char"
  },
  {
    "path": "tests/integration/docker-compose.yml",
    "chars": 8355,
    "preview": "x-common-env: &common-env\n  RUST_BACKTRACE: full\n  RUSTC_WRAPPER: ${SCCACHE_PATH:-/sccache/target/debug/sccache}\n  RUST_"
  },
  {
    "path": "tests/integration/msvc/args.rsp",
    "chars": 47,
    "preview": "foo.cpp -Fofoo.o /sourceDependencies foo.o.json"
  },
  {
    "path": "tests/integration/msvc/foo.cpp",
    "chars": 81,
    "preview": "#include <iostream>\n\nint main() {\n  std::cout << \"Hello World!\\n\";\n  return 0;\n}\n"
  },
  {
    "path": "tests/integration/msvc-preprocessing/args.rsp",
    "chars": 30,
    "preview": "foo.cpp -Fofoo.o -W4 -WX -Wall"
  },
  {
    "path": "tests/integration/msvc-preprocessing/foo.cpp",
    "chars": 769,
    "preview": "// This tests sccache's ability to handle a known bug in cl.exe\n// More information: https://github.com/mozilla/sccache/"
  },
  {
    "path": "tests/integration/randomize_readdir/Cargo.toml",
    "chars": 192,
    "preview": "[package]\nedition = \"2021\"\nname = \"randomize_readdir\"\nversion = \"0.1.0\"\n\n[dependencies]\nctor = \"0.2\"\nlibc = \"0.2.99\"\nlog"
  },
  {
    "path": "tests/integration/randomize_readdir/src/lib.rs",
    "chars": 8801,
    "preview": "// Copyright 2024 Mozilla Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "tests/integration/scripts/test-autotools.sh",
    "chars": 1212,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nSCCACHE=\"${SCCACHE_PATH:-/sccache/target/debug/sccache}\"\n\necho \"========================="
  },
  {
    "path": "tests/integration/scripts/test-backend.sh",
    "chars": 1740,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nTEST_NAME=\"${TEST_NAME:-unknown}\"\nBACKEND_CHECK=\"${BACKEND_CHECK:-}\"\nSCCACHE=\"${SCCACHE_P"
  },
  {
    "path": "tests/integration/scripts/test-basedirs.sh",
    "chars": 4886,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nSCCACHE=\"${SCCACHE_PATH:-/sccache/target/debug/sccache}\"\n\necho \"========================="
  },
  {
    "path": "tests/integration/scripts/test-clang.sh",
    "chars": 1522,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nSCCACHE=\"${SCCACHE_PATH:-/sccache/target/debug/sccache}\"\nTEST_FILE=\"/sccache/tests/test_c"
  },
  {
    "path": "tests/integration/scripts/test-cmake.sh",
    "chars": 1349,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nSCCACHE=\"${SCCACHE_PATH:-/sccache/target/debug/sccache}\"\n\necho \"========================="
  },
  {
    "path": "tests/integration/scripts/test-coverage.sh",
    "chars": 1313,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nSCCACHE=\"${SCCACHE_PATH:-/sccache/target/debug/sccache}\"\nexport RUSTFLAGS=\"-Cinstrument-c"
  },
  {
    "path": "tests/integration/scripts/test-gcc.sh",
    "chars": 1508,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nSCCACHE=\"${SCCACHE_PATH:-/sccache/target/debug/sccache}\"\nTEST_FILE=\"/sccache/tests/test_c"
  },
  {
    "path": "tests/integration/scripts/test-zstd.sh",
    "chars": 2466,
    "preview": "#!/bin/bash\nset -euo pipefail\n\nSCCACHE=\"${SCCACHE_PATH:-/sccache/target/debug/sccache}\"\n\necho \"========================="
  },
  {
    "path": "tests/integration/test_intel_asm.s",
    "chars": 367,
    "preview": ".data\n\nhello_str:\n    .string \"Hello, world!\\n\"\n\n\n    .set hello_str_length, . - hello_str - 1\n\n.text\n\n.globl  main\n\n.ty"
  },
  {
    "path": "tests/integration/test_intel_asm_to_preproc.S",
    "chars": 367,
    "preview": ".data\n\nhello_str:\n    .string \"Hello, world!\\n\"\n\n\n    .set hello_str_length, . - hello_str - 1\n\n.text\n\n.globl  main\n\n.ty"
  },
  {
    "path": "tests/integration/webdav-config.yaml",
    "chars": 104,
    "preview": "address: 0.0.0.0\nport: 8080\nprefix: /\n\nusers:\n  - username: bar\n    password: baz\n    permissions: CRUD\n"
  },
  {
    "path": "tests/integration/xcode/main.cpp",
    "chars": 109,
    "preview": "#include <iostream>\n\nint main(int argc, const char * argv[]) {\n\tstd::cout << \"Hello, World!\\n\";\n\treturn 0;\n}\n"
  },
  {
    "path": "tests/integration/xcode/sccache.xcconfig",
    "chars": 132,
    "preview": "C_COMPILER_LAUNCHER=../../../target/debug/sccache\nCLANG_ENABLE_MODULES=NO\nCOMPILER_INDEX_STORE_ENABLE=NO\nCLANG_USE_RESPO"
  },
  {
    "path": "tests/integration/xcode/xcode-test.xcodeproj/project.pbxproj",
    "chars": 9238,
    "preview": "// !$*UTF8*$!\n{\n\tarchiveVersion = 1;\n\tclasses = {\n\t};\n\tobjectVersion = 63;\n\tobjects = {\n\n/* Begin PBXBuildFile section *"
  },
  {
    "path": "tests/logging.rs",
    "chars": 4006,
    "preview": "// Tests for logging functionality.\n//\n// Copyright 2025 Mozilla Foundation\n//\n// Licensed under the Apache License, Ver"
  },
  {
    "path": "tests/msvc-msbuild/.gitignore",
    "chars": 32,
    "preview": "*\n!.gitignore\n!*.vcxproj\n!*.cpp\n"
  },
  {
    "path": "tests/msvc-msbuild/MsbuildCpp.vcxproj",
    "chars": 2415,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project DefaultTargets=\"Build\" xmlns=\"http://schemas.microsoft.com/developer/msb"
  },
  {
    "path": "tests/msvc-msbuild/test_bar.cpp",
    "chars": 29,
    "preview": "int bar(int x) { return x; }\n"
  },
  {
    "path": "tests/msvc-msbuild/test_baz.cpp",
    "chars": 29,
    "preview": "int baz(int x) { return x; }\n"
  },
  {
    "path": "tests/msvc-msbuild/test_foo.cpp",
    "chars": 29,
    "preview": "int foo(int x) { return x; }\n"
  },
  {
    "path": "tests/oauth.rs",
    "chars": 10236,
    "preview": "#![deny(rust_2018_idioms)]\n#![cfg(feature = \"dist-client\")]\n\nuse fs_err as fs;\nuse std::io::{self, Read, Write};\nuse std"
  },
  {
    "path": "tests/sccache_args.rs",
    "chars": 2135,
    "preview": "//! Tests for sccache args.\n//!\n//! Any copyright is dedicated to the Public Domain.\n//! http://creativecommons.org/publ"
  },
  {
    "path": "tests/sccache_cargo.rs",
    "chars": 12446,
    "preview": "//! System tests for compiling Rust code with cargo.\n//!\n//! Any copyright is dedicated to the Public Domain.\n//! http:/"
  },
  {
    "path": "tests/sccache_rustc.rs",
    "chars": 3869,
    "preview": "#![cfg(unix)]\n\nuse assert_cmd::Command;\nuse tempfile::tempdir;\n\nuse std::{\n    env::{consts::DLL_SUFFIX, var_os},\n    ff"
  },
  {
    "path": "tests/system.rs",
    "chars": 71719,
    "preview": "// System tests for compiling C code.\n//\n// Copyright 2016 Mozilla Foundation\n//\n// Licensed under the Apache License, V"
  },
  {
    "path": "tests/test-crate/Cargo.toml",
    "chars": 294,
    "preview": "[package]\nauthors = [\"Ted Mielczarek <ted@mielczarek.org>\"]\nname = \"test-crate\"\nversion = \"0.1.0\"\n\n[dependencies]\n# Arbi"
  },
  {
    "path": "tests/test-crate/src/bin.rs",
    "chars": 62,
    "preview": "extern crate mylib;\n\nfn main() {\n    mylib::env_dep_test();\n}\n"
  },
  {
    "path": "tests/test-crate/src/lib.rs",
    "chars": 189,
    "preview": "fn unused() {}\n\npub fn env_dep_test() {\n    println!(\"Env var: {}\", env!(\"TEST_ENV_VAR\"));\n}\n\n#[cfg(test)]\nmod tests {\n "
  },
  {
    "path": "tests/test.c",
    "chars": 62,
    "preview": "#include <stdio.h>\n\nvoid foo() {\n  printf(\"hello world\\n\");\n}\n"
  },
  {
    "path": "tests/test.c.gcc-13.2.0-preproc",
    "chars": 17967,
    "preview": "# 0 \"tests/test.c\"\n# 0 \"<built-in>\"\n# 0 \"<command-line>\"\n# 1 \"/usr/include/stdc-predef.h\" 1 3 4\n# 0 \"<command-line>\" 2\n#"
  },
  {
    "path": "tests/test_a.cu",
    "chars": 204,
    "preview": "\n#include <stdio.h>\n#include \"cuda_runtime.h\"\n\n__global__ void cuda_entry_point(int*, int*) {}\n__device__ void cuda_devi"
  },
  {
    "path": "tests/test_a.hip",
    "chars": 207,
    "preview": "\n#include <stdio.h>\n#include <hip/hip_runtime.h>\n\n__global__ void cuda_entry_point(int*, int*) {}\n__device__ void cuda_d"
  },
  {
    "path": "tests/test_b.cu",
    "chars": 204,
    "preview": "\n#include <stdio.h>\n#include \"cuda_runtime.h\"\n\n__global__ void cuda_entry_point(int*, int*) {}\n__device__ void cuda_devi"
  },
  {
    "path": "tests/test_b.hip",
    "chars": 207,
    "preview": "\n#include <stdio.h>\n#include <hip/hip_runtime.h>\n\n__global__ void cuda_entry_point(int*, int*) {}\n__device__ void cuda_d"
  },
  {
    "path": "tests/test_c.cu",
    "chars": 204,
    "preview": "\n#include <stdio.h>\n#include \"cuda_runtime.h\"\n\n__global__ void cuda_entry_point(int*, int*) {}\n__device__ void cuda_devi"
  },
  {
    "path": "tests/test_c.hip",
    "chars": 207,
    "preview": "\n#include <stdio.h>\n#include <hip/hip_runtime.h>\n\n__global__ void cuda_entry_point(int*, int*) {}\n__device__ void cuda_d"
  },
  {
    "path": "tests/test_clang_multicall.c",
    "chars": 209,
    "preview": "#include <iostream>\n\n// this is c++ code, but the extension is .c,\n// so clang doesn't change its behavior because of th"
  },
  {
    "path": "tests/test_err.c",
    "chars": 2,
    "preview": "x\n"
  },
  {
    "path": "tests/test_macro_expansion.c",
    "chars": 454,
    "preview": "#include <stdlib.h>\n\n#define foo(x)                                                                 \\\n  {               "
  },
  {
    "path": "tests/test_whitespace.c",
    "chars": 65,
    "preview": "#include <stdio.h>\n\nint main() {printf(\"Hello world!\");return 0;}"
  },
  {
    "path": "tests/test_whitespace_alt.c",
    "chars": 77,
    "preview": "#include <stdio.h>\n\nint main() \n\n\n{\n\n\n   printf(\"Hello world!\");\nreturn 0;\n}\n"
  },
  {
    "path": "tests/test_with_define.c",
    "chars": 144,
    "preview": "#include <stdio.h>\n\n#if !defined(SCCACHE_TEST_DEFINE)\n#error SCCACHE_TEST_DEFINE is not defined\n#endif\n\nvoid foo() { pri"
  }
]