Switch without a snapshot when the working copy is clean d3cd7ef95da6

    /// How many changes of the state left behind the new one lacks.

    pub lacks: usize,

        let _all = crate::timing::phase("checkout");

        // A working copy clean by the manifest needs no snapshot; otherwise a

        // status snapshot, which neither reads nor renders files the

        // manifest proves unchanged, and whose base is history only

        // (oxygen#35).

        let (base, changed_paths) = if self.clean_by_manifest()? {

            let (_, wc) = self.working_copy()?;

            (self.load_state_history(&wc.deps)?, Vec::new())

        } else {

            let snap = self.snapshot_status(command)?;

            self.refuse_dirty(&snap, discard)?;

            let paths = snap.statuses.iter().map(|s| s.path.clone()).collect();

            (snap.base, paths)

        };

        let views = crate::timing::phase("checkout: manifest and base view");

        let bview = base.tree().view();

        drop(views);

        let changed: HashSet<&str> = changed_paths.iter().map(String::as_str).collect();

        let tv = crate::timing::phase("checkout: target view");

        drop(tv);

        report.lacks = base.changes().filter(|(h, _)| !target.contains(h)).count();

        let gone: BTreeSet<&str> = bview

            .entries

            if bview

                .entries

        let plan = crate::timing::phase("checkout: plan");

                && bview

                    .entries

                // The manifest proves the file on disk equal to the base's

                // rendering (its key is the base graph's, and its stat was

                // checked just now), and the graph is the same in both

                // states: nothing to read, render or write.

                let key = base.graph_key(&e.node);

                    && key.is_some()

                    && key == target.graph_key(&e.node);

                let proven = |m: &&prompt::ManifestEntry| {

                    same_graph

                        && m.graph.as_deref() == key.map(|k| ObjectRef(k).to_hex()).as_deref()

                };

                match old_manifest.entries.get(path).filter(proven) {

        drop(plan);

        let _render = crate::timing::phase("checkout: render and write");

        drop(_render);

        let _t = crate::timing::phase("checkout: record and manifest");

    }

    /// Refuse to leave uncommitted work behind unless `discard`.

    fn refuse_dirty(&self, snap: &SnapshotResult, discard: bool) -> Result<()> {

        if discard || (snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty()) {

            return Ok(());

        }

        let list: Vec<String> = snap

            .statuses

            .iter()

            .take(8)

            .map(|s| format!("{} {}", status_word(s.status), s.path))

            .collect();

        fail(format!(

            "the working copy has changes ({}{}); commit them, take them along with --carry, or drop them with --discard",

            list.join(", "),

            if snap.statuses.len() > 8 { ", …" } else { "" }

        ))

    /// or commit found no uncommitted work and no conflict, there are no

    /// subrepos (whose state the manifest does not hold), and no file was

    /// added, removed or changed since. An entry inside the racy window,

    /// where an equal size and time do not prove equal content, is checked

    /// by hashing the file. `false` means only that a snapshot must decide.

        for (rel, e) in &m.entries {

            if e.mtime_ns + 2_000_000_000 < m.written_ns {

                continue;

            }

            let path = self.root.join(rel);

            let same = match fs::symlink_metadata(&path) {

                Ok(md) if md.file_type().is_symlink() => fs::read_link(&path).is_ok_and(|t| {

                    blake3::hash(t.to_string_lossy().as_bytes())

                        .to_hex()

                        .as_str()

                        == e.hash

                }),

                Ok(md) if md.is_file() => {

                    md.len() == e.size

                        && fs::read(&path)

                            .is_ok_and(|b| blake3::hash(&b).to_hex().as_str() == e.hash)

                }

                _ => false,

            };

            if !same {

                return Ok(false);

            }

            notes: vec![],

            lacks: 1,

}

/// A file written just before the manifest (inside the racy window) is

/// checked by its hash: trusted when equal, caught when edited in place

/// with the same size and time.

#[test]

fn a_racy_manifest_entry_is_checked_by_hash() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

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

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

    assert!(repo.clean_by_manifest().unwrap(), "fresh but equal");

    let t = fs::metadata(root.join("a.txt"))

        .unwrap()

        .modified()

        .unwrap();

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

    fs::File::options()

        .write(true)

        .open(root.join("a.txt"))

        .unwrap()

        .set_modified(t)

        .unwrap();

    assert!(

        !repo.clean_by_manifest().unwrap(),

        "same size and time, other bytes"

    );

    assert_eq!(

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

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

    );

A checkout of a working copy that is clean by the manifest now skips the

status snapshot, and a manifest entry inside the racy window is checked

by hashing the file rather than distrusting the whole manifest. A

one-file switch then takes 3.7 to 3.9 s and 705 MB. Where it goes:

checking the manifest (a walk of 96 000 files) 0.75 s, the base's and

the target's history 0.5 s each, their tree views 0.3 s each, planning

0.2 s, and writing the manifest 0.6 s.

    if r.lacks > 0 {

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "{name} lacks {} that {from} has",

                plural(r.lacks, "change")

            ))

        );