Incremental Compilation

// Support for serializing the dep-graph and reloading it

pub use persist::{
    LoadResult,
    setup_dep_graph,
    save_dep_graph,
    load_query_result_cache,
    finalize_session_directory,
    in_incr_comp_dir,
    copy_cgu_workproduct_to_incr_comp_cache_dir,
};

┌─────────────────┐
│  Source File    │
│  Changes        │
└────────┬────────┘
         │
         v
┌─────────────────┐
│  Parse Query    │  ← Invalidated
└────────┬────────┘
         │
         v
┌─────────────────┐
│  Type Check     │  ← Invalidated
│  Query          │
└────────┬────────┘
         │
         v
┌─────────────────┐
│  MIR Query      │  ← Invalidated
└────────┬────────┘
         │
         v
┌─────────────────┐
│  Codegen Query  │  ← Invalidated
└─────────────────┘

┌─────────────────┐
│  Unchanged      │
│  Function       │  ← Reused from cache!
└─────────────────┘

// Example query definitions:

/// Get the MIR for a function
query mir_built(key: LocalDefId) -> &'tcx Steal<Body<'tcx>> {
    storage(ArenaCacheSelector<'tcx>)
    cache_on_disk_if { true }
}

/// Type check a function
query type_of(key: DefId) -> Ty<'tcx> {
    cache_on_disk_if { key.is_local() }
}

/// Get optimized MIR
query optimized_mir(key: DefId) -> &'tcx Body<'tcx> {
    storage(ArenaCacheSelector<'tcx>)
    cache_on_disk_if { key.is_local() }
}

// Each node in the dependency graph has a fingerprint
// Fingerprints are computed from:
// - The query inputs
// - The query result
// - The source code

struct DepNode {
    kind: DepKind,
    hash: Fingerprint,
}

target/
└── debug/
    └── incremental/
        └── myproject-<hash>/
            ├── s-<session-id>.lock
            └── <work-product-id>/
                ├── dep-graph.bin
                ├── query-cache.bin
                └── work-products.bin

pub fn setup_dep_graph(
    tcx: TyCtxt<'_>,
) -> Result<LoadResult, ErrorGuaranteed> {
    // Load previous dependency graph if it exists
    // Set up tracking for current compilation
}

pub fn save_dep_graph(tcx: TyCtxt<'_>) {
    // Save dependency graph to disk
    // Save query results cache
    // Clean up old session directories
}

pub fn finalize_session_directory(
    tcx: TyCtxt<'_>,
) {
    // Mark session as complete
    // Copy work products to cache
}

fn foo() { /* ... */ }
fn bar() { /* change here */ }
fn baz() { /* ... */ }

// Only `bar` and its dependents are recompiled
// `foo` and `baz` are reused if they don't depend on `bar`

struct MyStruct {
    field: i32,  // change here
}

// Functions using MyStruct are recompiled
// Unrelated items are reused

mod my_module {
    // changes here...
}

// Only items that depend on my_module are recompiled

pub fn copy_cgu_workproduct_to_incr_comp_cache_dir(
    tcx: TyCtxt<'_>,
    cgu_name: &str,
    files: &[(WorkProductFileKind, PathBuf)],
) -> Result<(), ErrorGuaranteed> {
    // Copy compiled object files to cache
    // These can be reused if the CGU hasn't changed
}

// Query results are serialized using efficient encoding
// Large results are compressed
// Frequently accessed results are kept in memory

pub fn load_query_result_cache(
    tcx: TyCtxt<'_>,
) {
    // Load cached query results in parallel
    // Decompress and deserialize efficiently
}

# Enabled by default for debug builds
cargo build

# Force enable for release builds (slower but incremental)
cargo build --release -Z incremental

# Disable incremental compilation
CARGO_INCREMENTAL=0 cargo build

# Clean incremental cache
cargo clean -p myproject

# In Cargo.toml
[profile.dev]
incremental = true  # Default

[profile.release]
incremental = false  # Default

# Verbose incremental compilation output
RUSTC_LOG=rustc_incremental=debug cargo build

# Dump dependency graph
rustc -Z dump-dep-graph main.rs

# Assert dependency graph structure
rustc -Z query-dep-graph main.rs

# Verify incremental compilation
RUSTC_INCREMENTAL_VERIFY_ICH=1 cargo build