The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix: detect external file edits that preserve mtime and length (#1582)
Qingf3fe837a661d
diff --git a/Cargo.lock b/Cargo.lockindex 5a3e48cb0..276aeda0a 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4121,6 +4121,7 @@ dependencies = [name = "ide-build"version = "0.1.37"dependencies = [+ "blake3","dirs 6.0.0","dunce","ide-core",diff --git a/crates/ide-build/Cargo.toml b/crates/ide-build/Cargo.tomlindex bda630cf4..0de84af23 100644--- a/crates/ide-build/Cargo.toml+++ b/crates/ide-build/Cargo.toml@@ -6,6 +6,7 @@ edition.workspace = truelicense.workspace = true[dependencies]+blake3.workspace = truedunce.workspace = trueide-core.workspace = truezip.workspace = truediff --git a/crates/ide-build/src/compile/fingerprint.rs b/crates/ide-build/src/compile/fingerprint.rsindex 8274003d6..7ed4b9237 100644--- a/crates/ide-build/src/compile/fingerprint.rs+++ b/crates/ide-build/src/compile/fingerprint.rs@@ -2,18 +2,49 @@use super::*;use std::fs;use std::hash::{Hash, Hasher};+use std::io::Read;use std::time::SystemTime;+/// `(byte length, mtime, blake3 hex)`; the hash is recorded for files inside the project only.+type Stamp = (u64, SystemTime, Option<String>);+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]pub struct LaunchFingerprint {version: u32,parameters: String,- files: BTreeMap<PathBuf, Option<(u64, SystemTime)>>,+ /// Per input: a [`Stamp`] for regular files, `None` for+ /// directories and inputs that cannot be resolved. The content hash catches external+ /// edits that preserve both length and mtime (timestamp-preserving tools, coarse+ /// timestamp granularity), which `(length, mtime)` alone would miss. Only files inside+ /// the project are hashed; toolchain inputs such as the JDK's `lib/modules` keep the stamp.+ files: BTreeMap<PathBuf, Option<Stamp>>,+}++/// `blake3` hex of a file's bytes, streamed in chunks so memory stays bounded. An+/// unreadable file records a sentinel so one permission problem does not drop the whole+/// fingerprint (that would just force a normal rebuild).+fn content_hash(path: &Path) -> IdeResult<String> {+ let mut file = match fs::File::open(path) {+ Ok(file) => file,+ Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok("missing".into()),+ Err(e) => return Err(e.into()),+ };+ let mut hasher = blake3::Hasher::new();+ let mut buffer = [0; 64 * 1024];+ loop {+ let count = file.read(&mut buffer)?;+ if count == 0 {+ break;+ }+ hasher.update(&buffer[..count]);+ }+ Ok(hasher.finalize().to_hex().to_string())}fn scan(+ root: &Path,path: &Path,- files: &mut BTreeMap<PathBuf, Option<(u64, SystemTime)>>,+ files: &mut BTreeMap<PathBuf, Option<Stamp>>,ancestors: &mut HashSet<PathBuf>,cancel: &CancellationToken,) -> IdeResult<()> {@@ -36,11 +67,12 @@ fn scan(// Directory mtimes change on irrelevant JDT writes. File paths detect additions/deletions.files.insert(path.to_path_buf(), None);for entry in fs::read_dir(path)? {- scan(&entry?.path(), files, ancestors, cancel)?;+ scan(root, &entry?.path(), files, ancestors, cancel)?;}ancestors.remove(&canonical);} else if meta.is_file() {- files.insert(path.to_path_buf(), Some((meta.len(), meta.modified()?)));+ let hash = if path.starts_with(root) { Some(content_hash(path)?) } else { None };+ files.insert(path.to_path_buf(), Some((meta.len(), meta.modified()?, hash)));} else {return Err(IdeError::internal("unsupported launch input file"));}@@ -145,11 +177,11 @@ pub fn launch_fingerprint(.map_err(|e| IdeError::internal(e.to_string()))?;let mut files = BTreeMap::new();for path in inputs {- scan(&path, &mut files, &mut HashSet::new(), cancel)?;+ scan(root, &path, &mut files, &mut HashSet::new(), cancel)?;}// Store project inputs relative to the project, including each file's relative path.let files = files.into_iter().map(|(p, stamp)| (p.strip_prefix(root).unwrap_or(&p).to_path_buf(), stamp)).collect();- Ok(Some(LaunchFingerprint { version: 1, parameters, files }))+ Ok(Some(LaunchFingerprint { version: 2, parameters, files }))}#[cfg(test)]@@ -231,6 +263,25 @@ mod tests {}}+ /// An external tool that keeps the byte length and the mtime (timestamp-preserving+ /// writes, coarse-granularity filesystems) still changes the content: the fingerprint+ /// must differ via the content hash, not via `(length, mtime)`.+ #[test]+ fn external_edit_preserving_length_and_mtime_still_invalidates() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let source = root.join("lib/src/main/kotlin/Channel.kt");+ let before = fingerprint(root, &model);+ assert!(before.is_some());+ let mtime = fs::metadata(&source).unwrap().modified().unwrap();+ // Same 5-byte length, different content.+ write(root, "lib/src/main/kotlin/Channel.kt", "valve");+ fs::File::options().write(true).open(&source).unwrap().set_modified(mtime).unwrap();+ let after = fingerprint(root, &model);+ assert_ne!(before, after, "a same-length, same-mtime content change must invalidate the fingerprint");+ }+#[test]fn profile_options_jdk_goal_and_wrapper_invalidate_without_using_class_outputs() {let dir = tempfile::tempdir().unwrap();diff --git a/crates/ide-host/src/ops/java/cache.rs b/crates/ide-host/src/ops/java/cache.rsindex 422ade156..3f169c620 100644--- a/crates/ide-host/src/ops/java/cache.rs+++ b/crates/ide-host/src/ops/java/cache.rs@@ -242,6 +242,29 @@ mod tests {assert!(build().is_err());assert_eq!(fs::read_to_string(root.join("calls")).unwrap().lines().count(), 5);}+ /// An external tool (e.g. an AI code editor) rewrites a source file with the same byte+ /// length and preserves its mtime. The `(length, mtime)` fingerprint reads that as+ /// "unchanged" and would reuse the stale snapshot; the content hash must catch it.+ #[test]+ fn external_edit_preserving_length_and_mtime_rebuilds_the_snapshot() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let cache = root.join("cache");+ let cancel = CancellationToken::new();+ let mut session = Session::new(cache.clone());+ let first = session.build(root, &model, root, false, None, &cancel).unwrap();+ assert_eq!(fs::read_to_string(first.snapshot.join("0/Main.class")).unwrap(), "first");++ let source = root.join("src/main/kotlin/Main.kt");+ let mtime = fs::metadata(&source).unwrap().modified().unwrap();+ fs::write(&source, "other").unwrap(); // 5 bytes, same length as "first"+ fs::File::options().write(true).open(&source).unwrap().set_modified(mtime).unwrap();+ let rebuilt = session.build(root, &model, root, false, None, &cancel).unwrap();+ assert_ne!(rebuilt.snapshot, first.snapshot, "a same-length, same-mtime content change must rebuild");+ assert_eq!(fs::read_to_string(rebuilt.snapshot.join("0/Main.class")).unwrap(), "other");+ }+#[test]fn session_drop_removes_superseded_snapshots_and_preserves_records_across_reopen() {let dir = tempfile::tempdir().unwrap();diff --git a/crates/ide-workspace/src/documents.rs b/crates/ide-workspace/src/documents.rsindex 7ecd16a38..cf64493e7 100644--- a/crates/ide-workspace/src/documents.rs+++ b/crates/ide-workspace/src/documents.rs@@ -868,17 +868,18 @@ impl Documents {.then(|| st.path.clone())}).collect();- self.reload_from_disk(&paths, force_clean);+ self.reload_from_disk(&paths, force_clean, true);}/// Re-reads from disk after an external change. Clean documents reload/// silently; dirty ones are left alone and reported via `IdeEvent::Notify`./// Changes matching our own last save are ignored.pub fn on_disk_changed(&self, paths: &[PathBuf]) {- self.reload_from_disk(paths, false);+ self.reload_from_disk(paths, false, false);}- fn reload_from_disk(&self, paths: &[PathBuf], force_clean: bool) {+ /// `dedup`: blind scans skip files whose `(mtime, length)` stamp still matches.+ fn reload_from_disk(&self, paths: &[PathBuf], force_clean: bool, dedup: bool) {for path in paths {let Some(id) = self.by_path(path) else { continue };let result = self.with_doc(id, |st| {@@ -887,7 +888,23 @@ impl Documents {}let Ok(meta) = std::fs::metadata(&st.path) else { return Ok(()) };let mtime = ide_vfs::mtime_ms(&meta);- if mtime == st.disk_mtime && meta.len() == st.disk_len && (!force_clean || st.dirty) {+ let unchanged = mtime == st.disk_mtime && meta.len() == st.disk_len;+ // Blind scans trust the stamp. OS events are authoritative, but they also+ // echo our own saves: a clean document whose stamp matches is re-checked by+ // bytes — an external write that preserved both length and mtime differs+ // from what saving this buffer would write, our own save's echo does not.+ // Native-to-ascii properties documents and dirty documents keep the stamp+ // dedup: the former's disk bytes legitimately differ from the buffer text,+ // the latter warn once per disk state.+ if unchanged+ && (!force_clean || st.dirty)+ && (dedup+ || st.dirty+ || st.native_to_ascii+ || ide_vfs::encode(&st.doc.text_for_save(), &st.encoding, st.has_bom)+ .map(|bytes| bytes == std::fs::read(&st.path).unwrap_or_default())+ .unwrap_or(true))+ {return Ok(());}if st.dirty {diff --git a/crates/ide-workspace/tests/documents.rs b/crates/ide-workspace/tests/documents.rsindex 52c20e959..794af1cf6 100644--- a/crates/ide-workspace/tests/documents.rs+++ b/crates/ide-workspace/tests/documents.rs@@ -403,6 +403,46 @@ fn external_changes() {f.docs.on_disk_changed(&[f.root.join("other.txt")]);}+/// An IDE operation that rewrites a file with the same length and mtime still refreshes+/// the clean buffer.+#[test]+fn own_disk_change_preserving_length_and_mtime_reloads_a_clean_document() {+ let f = fixture();+ let path = f.root.join("stamp.txt");+ fs::write(&path, "first").unwrap();+ let id = f.docs.open(&path).unwrap().id;+ let mtime = fs::metadata(&path).unwrap().modified().unwrap();+ fs::write(&path, "other").unwrap();+ fs::File::options().write(true).open(&path).unwrap().set_modified(mtime).unwrap();+ f.docs.sync_after_disk_change();+ assert_eq!(f.docs.snapshot(id).unwrap().text, "other");+}++/// An external write that keeps the byte length and the mtime (timestamp-preserving+/// tools, coarse-granularity filesystems) leaves the `(mtime, length)` stamp equal:+/// the OS event is still authoritative, so a clean document reloads.+#[test]+fn external_change_preserving_length_and_mtime_reloads_a_clean_document() {+ let f = fixture();+ let path = f.root.join("stamp.txt");+ fs::write(&path, "first").unwrap(); // 5 bytes+ let id = f.docs.open(&path).unwrap().id;+ let mtime = fs::metadata(&path).unwrap().modified().unwrap();++ fs::write(&path, "other").unwrap(); // 5 bytes, different content+ fs::File::options().write(true).open(&path).unwrap().set_modified(mtime).unwrap();+ f.docs.on_disk_changed(std::slice::from_ref(&path));+ let snap = f.docs.snapshot(id).unwrap();+ assert_eq!(snap.text, "other");+ assert!(!snap.dirty);++ // The reload recorded the new stamp: repeating the same event changes nothing.+ let before = f.events.lock().len();+ f.docs.on_disk_changed(std::slice::from_ref(&path));+ assert_eq!(f.events.lock().len(), before);+ assert_eq!(f.docs.snapshot(id).unwrap().text, "other");+}+#[test]fn encodings_and_read_only() {let f = fixture();