Sensitive to the order inputs and outputs are listed? about n2 HOT 9 CLOSED

diff --git a/src/graph.rs b/src/graph.rs
index 506023d..f1f60a6 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -377,7 +377,7 @@ const UNIT_SEPARATOR: u8 = 0x1F;
 fn hash_files(
     hasher: &mut std::collections::hash_map::DefaultHasher,
     graph: &Graph,
-    file_state: &mut FileState,
+    file_state: &FileState,
     ids: &[FileId],
 ) {
     for &id in ids {
@@ -395,6 +395,31 @@ fn hash_files(
     }
 }
 
+pub fn dump_files(
+    dump: &mut Vec<(String, i64)>,
+    graph: &Graph,
+    file_state: &FileState,
+    ids: &[FileId],
+) {
+    for &id in ids {
+        let name = &graph.file(id).name;
+        let mtime = file_state
+            .get(id)
+            .unwrap_or_else(|| panic!("no state for {:?}", name));
+        let mtime = match mtime {
+            MTime::Stamp(mtime) => mtime,
+            MTime::Missing => panic!("missing file: {:?}", name),
+        };
+        dump.push((
+            name.clone(),
+            mtime
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_millis() as i64,
+        ));
+    }
+}
+
 // Hashes the inputs of a build to compute a signature.
 // Prerequisite: all referenced files have already been stat()ed and are present.
 // (It doesn't make sense to hash a build with missing files, because it's out
@@ -417,6 +442,27 @@ pub fn hash_build(
     Ok(Hash(hasher.finish()))
 }
 
+#[derive(Default, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
+pub struct BuildDump {
+    pub ins: Vec<(String, i64)>,
+    pub outs: Vec<(String, i64)>,
+    pub cmdline: String,
+}
+
+pub fn dump_build(
+    graph: &Graph,
+    file_state: &FileState,
+    build: &Build,
+) -> std::io::Result<BuildDump> {
+    let mut dump = BuildDump::default();
+    dump_files(&mut dump.ins, graph, file_state, build.dirtying_ins());
+    dump_files(&mut dump.ins, graph, file_state, build.discovered_ins());
+    dump_files(&mut dump.outs, graph, file_state, build.outs());
+    dump.cmdline = build.cmdline.clone().unwrap_or_default();
+    assert!(build.rspfile.is_none());
+
+    Ok(dump)
+}
 #[derive(Default)]
 pub struct Hashes(HashMap<BuildId, Hash>);
 
diff --git a/src/work.rs b/src/work.rs
index 227f5bb..9363c6f 100644
--- a/src/work.rs
+++ b/src/work.rs
@@ -4,8 +4,10 @@ use crate::{
     canon::canon_path, db, densemap::DenseMap, graph::*, progress, progress::Progress, signal,
     smallmap::SmallMap, task, trace,
 };
+use std::collections::HashMap;
 use std::collections::HashSet;
 use std::collections::VecDeque;
+use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
 
@@ -292,6 +294,7 @@ pub struct Work<'a> {
     last_hashes: &'a Hashes,
     build_states: BuildStates,
     runner: task::Runner,
+    dump: HashMap<String, BuildDump>,
 }
 
 impl<'a> Work<'a> {
@@ -315,6 +318,7 @@ impl<'a> Work<'a> {
             last_hashes,
             build_states: BuildStates::new(builds, pools),
             runner: task::Runner::new(parallelism),
+            dump: Default::default(),
         }
     }
 
@@ -598,6 +602,13 @@ impl<'a> Work<'a> {
         // so compare the hash against the last hash.
         // TODO: skip this whole function if no previous hash is present.
         let hash = hash_build(self.graph, &mut self.file_state, build)?;
+
+        assert!(build.cmdline.is_some());
+        self.dump.insert(
+            build.cmdline.clone().unwrap(),
+            dump_build(self.graph, &self.file_state, build)?,
+        );
+
         Ok(self.last_hashes.changed(id, hash))
     }
 
@@ -725,6 +736,37 @@ impl<'a> Work<'a> {
         // "interrupted by user" and exit with success, and in that case we
         // don't want n2 to print a "succeeded" message afterwards.
         let success = tasks_failed == 0 && !signal::was_interrupted();
+        if success {
+            let dump_path = Path::new(".n2-dump");
+            if dump_path.exists() {
+                let previous_dump: HashMap<String, BuildDump> =
+                    serde_json::from_slice(&std::fs::read(dump_path).unwrap()).unwrap();
+
+                for (k, current) in &self.dump {
+                    match previous_dump.get(k) {
+                        Some(prev) => {
+                            if prev != current {
+                                let old = serde_json::to_string(prev).unwrap();
+                                let new = serde_json::to_string(current).unwrap();
+                                println!(
+                                    "{k}: {:#?}",
+                                    json_diff::compare_jsons(&old, &new).unwrap()
+                                );
+                            }
+                        }
+                        None => {
+                            println!("not seen before: {}", k);
+                        }
+                    }
+                }
+
+                for (k, v) in previous_dump {
+                    // add any previous entries that are missing to current dump
+                    self.dump.entry(k).or_insert(v);
+                }
+            };
+            std::fs::write(dump_path, serde_json::to_vec(&self.dump).unwrap()).unwrap();
+        }
         Ok(success.then(|| tasks_done))
     }