Stat cache for text files: a stat-clean file whose recorded hash is the base's rendering takes the base's bytes instead of being read; edits are always read (spec 12.4) 696bbf29d3eb

        let entries = self.walk_working_copy_with(None, &Self::tracked_kinds(&target), None)?;

        self.walk_working_copy_with(None, &BTreeMap::new(), None)

        base: Option<&crate::state::Snapshot>,

                    let base_text = base.and_then(|b| match b.files.get(rel).map(|f| &f.content) {

                        Some(crate::state::FileContent::Text { bytes, .. }) => {

                            Some(bytes.as_slice())

                        }

                        _ => None,

                    });

                    Ok((

                        rel.clone(),

                        read_file_entry(rel, path, meta, cache, base_text)?,

                    ))

        let mut e = read_file_entry(rel, path, meta, cache, None)?;

/// Read one working-copy file. With a manifest whose stat for it is

/// unchanged (and not racy), an opaque file is not read at all (its stored

/// blob stands in), and a text file whose recorded hash equals the base

/// state's rendering of that path takes the base's bytes instead of reading

/// the disk (spec §12.3): equal hashes mean equal bytes, so the change built

/// from it is the same.

    base_text: Option<&[u8]>,

        Some(e) => {

            let from_base = base_text.filter(|b| {

                b.len() as u64 == e.size && blake3::hash(b).to_hex().as_str() == e.hash

            });

            FsEntry {

                kind: NodeKind::File,

                exec,

                content: match from_base {

                    Some(b) => b.to_vec(),

                    None => fs::read(path)?,

                },

                blob: None,

                content_hash: Some(e.hash.clone()),

            }

        }

            self.walk_working_copy_with(None, &Self::tracked_kinds(base_snapshot), None)?;

            self.walk_working_copy_with(

                manifest.as_ref(),

                &Self::tracked_kinds(&base_snapshot),

                Some(&base_snapshot),

            )?

/// A text file whose stat matches the manifest and whose recorded hash is

/// the base's content is taken from the base without reading it; anything

/// else is read, so no edit is missed (spec §12.3).

#[cfg(unix)]

#[test]

fn stat_cache_takes_unchanged_text_from_the_base_and_misses_no_edit() {

    use std::os::unix::fs::PermissionsExt;

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let repo = Repo::init(root).unwrap().with_home(root.join("home"));

    write(root, "a.txt", b"one\ntwo\n");

    write(root, "b.txt", b"bee\n");

    repo.commit("base", &[]).unwrap();

    let age = |p: &str| {

        let old = std::time::SystemTime::now() - std::time::Duration::from_secs(30);

        fs::File::options()

            .write(true)

            .open(root.join(p))

            .unwrap()

            .set_modified(old)

            .unwrap();

    };

    age("a.txt");

    age("b.txt");

    assert!(

        !repo.snapshot("status").unwrap().changed,

        "records the aged stat"

    );

    // Clean and equal to the base: not read at all.

    fs::set_permissions(root.join("a.txt"), fs::Permissions::from_mode(0o000)).unwrap();

    let snap = repo.snapshot("status").unwrap();

    assert!(

        !snap.changed && snap.statuses.is_empty(),

        "{:?}",

        snap.statuses

    );

    fs::set_permissions(root.join("a.txt"), fs::Permissions::from_mode(0o644)).unwrap();

    // An uncommitted edit that is older than the manifest: stat-clean, but

    // its hash is not the base's, so it is read and stays visible.

    write(root, "b.txt", b"bee edited\n");

    age("b.txt");

    let first = repo.snapshot("status").unwrap();

    assert_eq!(

        statuses(&first),

        vec![("b.txt".to_string(), ChangeStatus::Modified)]

    );

    let again = repo.snapshot("status").unwrap();

    assert_eq!(

        statuses(&again),

        vec![("b.txt".to_string(), ChangeStatus::Modified)],

        "still seen once stat-clean"

    );

    assert!(!again.changed, "and the working copy hashes the same");

    fs::set_permissions(root.join("b.txt"), fs::Permissions::from_mode(0o000)).unwrap();

    assert!(

        repo.snapshot("status").is_err(),

        "an edited file must be read, never taken from the base"

    );

    fs::set_permissions(root.join("b.txt"), fs::Permissions::from_mode(0o644)).unwrap();

    // A same-size edit made just now is racy and read.

    write(root, "a.txt", b"one\nTWO\n");

    assert_eq!(

        statuses(&repo.snapshot("status").unwrap()),

        vec![

            ("a.txt".to_string(), ChangeStatus::Modified),

            ("b.txt".to_string(), ChangeStatus::Modified)

        ]

    );

    // Committing makes the edits the base: both are clean and served from it again.

    repo.commit("edits", &[]).unwrap();

    age("a.txt");

    age("b.txt");

    assert!(repo.snapshot("status").unwrap().statuses.is_empty());

    fs::set_permissions(root.join("a.txt"), fs::Permissions::from_mode(0o000)).unwrap();

    fs::set_permissions(root.join("b.txt"), fs::Permissions::from_mode(0o000)).unwrap();

    let snap = repo.snapshot("status").unwrap();

    assert!(!snap.changed && snap.statuses.is_empty());

    fs::set_permissions(root.join("a.txt"), fs::Permissions::from_mode(0o644)).unwrap();

    fs::set_permissions(root.join("b.txt"), fs::Permissions::from_mode(0o644)).unwrap();

}

The reference implementation's cache is the workspace **manifest** written after every snapshot, commit, and checkout: per file its size, mtime, content hash, and, for an opaque file, the ObjectRef of its stored blob. On the next snapshot a file whose size and mtime match is not read: an opaque file contributes its recorded blob, a text file keeps its recorded hash, and when that hash equals the hash of the base state's rendering of the path, its bytes are taken from the base instead of the disk (equal hashes mean equal bytes; a stat-clean file that differs from the base, such as an older uncommitted edit, is always read). A file whose mtime lies within two seconds of the manifest's own write time is never trusted (the racy-stat window), so a modification that preserves size and lands in the same timestamp tick is still seen. An implementation MAY use a file-system monitor instead of, or in addition to, the manifest.