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(editor): skip clean saves and refresh buffers after disk operations (#920)
l0ng-ai0a24b79b50bd
diff --git a/crates/ide-host/src/ops/fs.rs b/crates/ide-host/src/ops/fs.rsindex fb55f6f0f..7c56cd3a3 100644--- a/crates/ide-host/src/ops/fs.rs+++ b/crates/ide-host/src/ops/fs.rs@@ -56,14 +56,16 @@ pub async fn copy_merge(if overwrite {project.history.record_deletion(&to, DELETE_SNAPSHOT_LIMIT);}- ide_vfs::copy_merge(- &from,- &to,- overwrite,- Some(&project.root),- &project.exclude_globs(),- (&source_root, &destination_root),- )+ project.with_disk_sync(|| {+ ide_vfs::copy_merge(+ &from,+ &to,+ overwrite,+ Some(&project.root),+ &project.exclude_globs(),+ (&source_root, &destination_root),+ )+ })}).await}diff --git a/crates/ide-host/src/ops/vcs/commands.rs b/crates/ide-host/src/ops/vcs/commands.rsindex eae55b6b9..d3913c0af 100644--- a/crates/ide-host/src/ops/vcs/commands.rs+++ b/crates/ide-host/src/ops/vcs/commands.rs@@ -281,7 +281,7 @@ pub async fn vcs_add_to_ignore(}}apply_git_executable(&project.settings.effective());- let result = ide_vcs::add_to_ignore(&paths, destination);+ let result = project.with_disk_sync(|| ide_vcs::add_to_ignore(&paths, destination));// Exclude may live outside a worktree's watched directory. Refresh filters and UI explicitly.project.watcher.reload_ignore_rules();for (_, watcher) in project.content_watchers.lock().iter() {@@ -322,7 +322,7 @@ pub async fn vcs_commit(// Commit hooks may run for a long time.let project = host.project(window)?;blocking(move || {- project.with_repo_at(repo.as_deref(), |r| {+ project.with_repo_recorded(repo.as_deref(), None, |r| {r.commit_with(&message, &options, &|path| project.vcs_encoding(path, None))})})@@ -729,7 +729,7 @@ pub async fn vcs_add_worktree(host.require_trust(window)?;let project = host.project(window)?;blocking(move || {- project.with_repo_at(repo.as_deref(), |r| r.add_worktree(&path, &commitish, new_branch.as_deref()))+ project.with_repo_recorded(repo.as_deref(), None, |r| r.add_worktree(&path, &commitish, new_branch.as_deref()))}).await}@@ -846,7 +846,7 @@ pub async fn vcs_apply_patch() -> IdeResult<ApplyOutcome> {host.require_trust(window)?;let project = host.project(window)?;- blocking(move || project.with_repo_at(repo.as_deref(), |r| r.apply_patch(&patch))).await+ blocking(move || project.with_repo_recorded(repo.as_deref(), None, |r| r.apply_patch(&patch))).await}/// Shelve Changes: saves the changes of `paths` as a patch on the shelf and reverts them.@@ -948,13 +948,20 @@ pub fn vcs_changelists_save(host: &Host, window: &str, changelists: ChangelistSt}/// Create Patch › Save to file.-pub async fn vcs_write_patch(_host: &Host, _window: &str, path: PathBuf, patch: String) -> IdeResult<()> {+pub async fn vcs_write_patch(host: &Host, window: &str, path: PathBuf, patch: String) -> IdeResult<()> {+ let project = host.project(window).ok();blocking(move || {- if let Some(dir) = path.parent() {- std::fs::create_dir_all(dir)?;+ let write = || {+ if let Some(dir) = path.parent() {+ std::fs::create_dir_all(dir)?;+ }+ std::fs::write(&path, patch)?;+ Ok(())+ };+ match project {+ Some(project) => project.with_disk_sync(write),+ None => write(),}- std::fs::write(&path, patch)?;- Ok(())}).await}diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex a42889a19..9b4dda808 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -682,17 +682,24 @@ impl Project {self.with_repo_at(None, f)}+ pub(crate) fn with_disk_sync<T>(&self, f: impl FnOnce() -> IdeResult<T>) -> IdeResult<T> {+ let result = f();+ // Failed operations can also leave changed files (for example merge conflicts).+ self.documents.sync_after_disk_change();+ result+ }+/// Runs a VCS operation that rewrites the working tree (checkout, merge,/// rebase, pull, reset, stash, rollback): Local History gets a label and a/// snapshot of every locally changed file before, and a label after.- /// `None` runs `f` like [`with_repo`](Self::with_repo) (operations that keep the working tree).+ /// Clean buffers follow the resulting files before returning; `None` omits the history labels.pub fn with_repo_recorded<T>(&self,at: Option<&Path>,operation: Option<&str>,f: impl FnOnce(&Repo) -> IdeResult<T>,) -> IdeResult<T> {- let Some(name) = operation else { return self.with_repo_at(at, f) };+ let Some(name) = operation else { return self.with_disk_sync(|| self.with_repo_at(at, f)) };self.history_label(&format!("Before {name}"));if let Ok(changed) = self.with_repo_at(at, |r| r.status()) {for file in changed.iter().take(HISTORY_BATCH_LIMIT) {@@ -701,7 +708,7 @@ impl Project {}}}- let result = self.with_repo_at(at, f);+ let result = self.with_disk_sync(|| self.with_repo_at(at, f));self.history_label(&format!("After {name}"));result}diff --git a/crates/ide-host/tests/vcs_documents.rs b/crates/ide-host/tests/vcs_documents.rsnew file mode 100644index 000000000..b6ca6fbec--- /dev/null+++ b/crates/ide-host/tests/vcs_documents.rs@@ -0,0 +1,240 @@+use ide_core::{ChangeSet, NullSink, TextChange};+use ide_host::{Host, HostConfig, Project, ops::vcs};+use std::{path::Path, process::Command, sync::Arc, time::Duration};++const ORIGINAL: &str = "SELECT *\nFROM patients\n\tLIMIT 10 OFFSET 0";+const OTHER: &str = "SELECT id\nFROM patients\n\tLIMIT 20 OFFSET 0";++fn git(root: &Path, args: &[&str]) -> String {+ let out = Command::new("git").current_dir(root).args(args).output().unwrap();+ assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));+ String::from_utf8(out.stdout).unwrap()+}++struct Fixture {+ host: Host,+ project: Arc<Project>,+ path: std::path::PathBuf,+ doc: ide_core::DocId,+ _temp: tempfile::TempDir,+}++impl Fixture {+ async fn new() -> Self {+ let temp = tempfile::tempdir().unwrap();+ let base = dunce::canonicalize(temp.path()).unwrap();+ let root = base.join("project");+ // The command must synchronize documents even when watcher delivery is excluded.+ let path = root.join("node_modules/query.sql");+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();+ git(&root, &["init", "-b", "main"]);+ git(&root, &["config", "user.name", "Test"]);+ git(&root, &["config", "user.email", "[email protected]"]);+ git(&root, &["config", "commit.gpgsign", "false"]);+ git(&root, &["config", "core.autocrlf", "false"]);+ std::fs::write(&path, ORIGINAL).unwrap();+ git(&root, &["add", "-f", "node_modules/query.sql"]);+ git(&root, &["commit", "-m", "original"]);+ git(&root, &["switch", "-c", "other"]);+ std::fs::write(&path, OTHER).unwrap();+ git(&root, &["commit", "-am", "other"]);+ git(&root, &["switch", "main"]);+ let host = Host::new(HostConfig {+ config_dir: base.join("config"),+ data_dir: base.join("data"),+ local_data_dir: base.join("data"),+ languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),+ syntax: Arc::default(),+ sink_for: Box::new(|_| Arc::new(NullSink)),+ owner: |w| w,+ runtime: tokio::runtime::Handle::current(),+ project_environment: false,+ });+ host.trust.decide(&root, true, false).unwrap();+ let project = host.open_project("main", &root).unwrap();+ for _ in 0..500 {+ if !project.repos().is_empty() {+ break;+ }+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ let doc = project.documents.open(&path).unwrap().id;+ Self { host, project, path, doc, _temp: temp }+ }++ fn saved_edit(&self, text: &str) {+ self.project.documents.replace_all(self.doc, text).unwrap();+ self.project.documents.save(self.doc).unwrap();+ }++ fn assert_clean(&self, text: &str) {+ let snapshot = self.project.documents.snapshot(self.doc).unwrap();+ assert_eq!(snapshot.text, text);+ assert!(!snapshot.dirty);+ self.project.documents.save_all().unwrap();+ assert_eq!(std::fs::read_to_string(&self.path).unwrap(), text);+ }+}++impl Drop for Fixture {+ fn drop(&mut self) {+ self.host.close_project("main");+ }+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn checkout_reloads_clean_open_documents_before_returning() {+ let f = Fixture::new().await;+ vcs::vcs_checkout(&f.host, "main", None, "other".into(), false, None).await.unwrap();+ f.assert_clean(OTHER);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn rollback_reloads_clean_open_documents_before_returning() {+ let f = Fixture::new().await;+ f.saved_edit(&format!("{ORIGINAL}\n"));+ vcs::vcs_discard(&f.host, "main", vec![f.path.clone()]).await.unwrap();+ f.assert_clean(ORIGINAL);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn stash_and_unstash_reload_clean_open_documents_before_returning() {+ let f = Fixture::new().await;+ let edited = format!("{ORIGINAL}\n");+ f.saved_edit(&edited);+ vcs::vcs_stash_push(&f.host, "main", None, None, false, false).await.unwrap();+ f.assert_clean(ORIGINAL);+ vcs::vcs_stash_apply(&f.host, "main", None, 0, true, false, None).await.unwrap();+ f.assert_clean(&edited);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn applying_patch_reloads_clean_open_documents_before_returning() {+ let f = Fixture::new().await;+ std::fs::write(&f.path, OTHER).unwrap();+ let patch = git(&f.project.root, &["diff"]);+ git(&f.project.root, &["restore", "."]);+ vcs::vcs_apply_patch(&f.host, "main", None, patch).await.unwrap();+ f.assert_clean(OTHER);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn writing_patch_file_reloads_its_clean_open_document() {+ let f = Fixture::new().await;+ vcs::vcs_write_patch(&f.host, "main", f.path.clone(), OTHER.into()).await.unwrap();+ f.assert_clean(OTHER);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn directory_compare_overwrite_reloads_clean_open_documents() {+ let f = Fixture::new().await;+ let base = f.project.root.parent().unwrap();+ let source = base.join("source");+ let destination = base.join("destination");+ std::fs::create_dir_all(&source).unwrap();+ std::fs::create_dir_all(&destination).unwrap();+ std::fs::write(source.join("query.sql"), OTHER).unwrap();+ let path = destination.join("query.sql");+ std::fs::write(&path, ORIGINAL).unwrap();+ let doc = f.project.documents.open(&path).unwrap();+ ide_host::ops::fs::copy_merge(&f.host, "main", source, destination, "query.sql".into(), true).await.unwrap();+ let snapshot = f.project.documents.snapshot(doc.id).unwrap();+ assert_eq!(snapshot.text, OTHER);+ assert!(!snapshot.dirty);+ f.project.documents.save_all().unwrap();+ assert_eq!(std::fs::read_to_string(&path).unwrap(), OTHER);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn failed_working_tree_operation_synchronizes_partial_disk_changes() {+ let f = Fixture::new().await;+ let result: ide_core::IdeResult<()> = f.project.with_repo_recorded(None, Some("Git merge"), |_| {+ std::fs::write(&f.path, OTHER).unwrap();+ Err(ide_core::IdeError::invalid("merge stopped with conflicts"))+ });+ assert!(result.is_err());+ f.assert_clean(OTHER);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn working_tree_operation_reloads_same_size_same_timestamp_changes() {+ let f = Fixture::new().await;+ let modified = std::fs::metadata(&f.path).unwrap().modified().unwrap();+ let replacement = ORIGINAL.replace("LIMIT 10", "LIMIT 20");+ f.project+ .with_repo_recorded(None, Some("Git checkout"), |_| {+ std::fs::write(&f.path, &replacement).unwrap();+ std::fs::File::options()+ .write(true)+ .open(&f.path)+ .unwrap()+ .set_times(std::fs::FileTimes::new().set_modified(modified))+ .unwrap();+ Ok(())+ })+ .unwrap();+ f.assert_clean(&replacement);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn working_tree_operation_does_not_discard_unsaved_edits() {+ let f = Fixture::new().await;+ let version = f.project.documents.snapshot(f.doc).unwrap().version;+ f.project+ .documents+ .edit(f.doc, version, ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: "-- local\n".into() }] })+ .unwrap();+ vcs::vcs_checkout(&f.host, "main", None, "other".into(), false, None).await.unwrap();+ let snapshot = f.project.documents.snapshot(f.doc).unwrap();+ assert_eq!(snapshot.text, format!("-- local\n{ORIGINAL}"));+ assert!(snapshot.dirty);+ assert_eq!(std::fs::read_to_string(&f.path).unwrap(), OTHER);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn adding_local_exclude_reloads_open_ignore_document() {+ let f = Fixture::new().await;+ let path = f.project.root.join(".git/info/exclude");+ let doc = f.project.documents.open(&path).unwrap();+ let ignored = f.project.root.join("generated.txt");+ std::fs::write(&ignored, "generated\n").unwrap();+ vcs::vcs_add_to_ignore(&f.host, "main", vec![ignored], ide_vcs::IgnoreDestination::LocalExclude).await.unwrap();+ let disk = std::fs::read_to_string(&path).unwrap();+ assert!(disk.contains("/generated.txt"));+ assert_eq!(f.project.documents.snapshot(doc.id).unwrap().text, disk);+}++#[cfg(unix)]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn commit_hook_reloads_clean_open_documents() {+ use std::os::unix::fs::PermissionsExt;+ let f = Fixture::new().await;+ f.saved_edit(&format!("{ORIGINAL}\n"));+ git(&f.project.root, &["add", "-u"]);+ let hook = f.project.root.join(".git/hooks/pre-commit");+ std::fs::write(&hook, "#!/bin/sh\nprintf 'SELECT hook;' > node_modules/query.sql\n").unwrap();+ std::fs::set_permissions(&hook, std::fs::Permissions::from_mode(0o755)).unwrap();+ vcs::vcs_commit(+ &f.host,+ "main",+ None,+ "commit with hook".into(),+ ide_vcs::CommitOptions { run_hooks: true, ..Default::default() },+ )+ .await+ .unwrap();+ f.assert_clean("SELECT hook;");+}++#[cfg(unix)]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn worktree_checkout_hook_reloads_clean_open_documents() {+ use std::os::unix::fs::PermissionsExt;+ let f = Fixture::new().await;+ let hook = f.project.root.join(".git/hooks/post-checkout");+ std::fs::write(&hook, "#!/bin/sh\nprintf 'SELECT hook;' > ../project/node_modules/query.sql\n").unwrap();+ std::fs::set_permissions(&hook, std::fs::Permissions::from_mode(0o755)).unwrap();+ let linked = f.project.root.parent().unwrap().join("linked");+ vcs::vcs_add_worktree(&f.host, "main", None, linked, "other".into(), None).await.unwrap();+ f.assert_clean("SELECT hook;");+}diff --git a/crates/ide-workspace/src/documents.rs b/crates/ide-workspace/src/documents.rsindex 8ea241afb..dbcee862b 100644--- a/crates/ide-workspace/src/documents.rs+++ b/crates/ide-workspace/src/documents.rs@@ -821,6 +821,17 @@ impl Documents {/// Re-checks open file buffers, including files outside the watched roots./// Call from a blocking worker; unchanged files only need their metadata.pub fn sync_from_disk(&self) {+ self.sync_open_documents(false);+ }++ /// Refreshes clean buffers after an IDE operation rewrites files. Such an+ /// operation can preserve both file length and the timestamp's millisecond.+ /// The open document's selected codec is retained.+ pub fn sync_after_disk_change(&self) {+ self.sync_open_documents(true);+ }++ fn sync_open_documents(&self, force_clean: bool) {let slots: Vec<Slot> = self.registry.lock().docs.values().map(|e| e.slot.clone()).collect();let paths: Vec<PathBuf> = slots.iter()@@ -830,13 +841,17 @@ impl Documents {.then(|| st.path.clone())}).collect();- self.on_disk_changed(&paths);+ self.reload_from_disk(&paths, force_clean);}/// 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);+ }++ fn reload_from_disk(&self, paths: &[PathBuf], force_clean: bool) {for path in paths {let Some(id) = self.by_path(path) else { continue };let result = self.with_doc(id, |st| {@@ -845,7 +860,7 @@ 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 {+ if mtime == st.disk_mtime && meta.len() == st.disk_len && (!force_clean || st.dirty) {return Ok(());}if st.dirty {@@ -863,9 +878,14 @@ impl Documents {});return Ok(());}- let defaults = self.file_defaults();- let loaded = Self::load_with_defaults(&st.path, &defaults)?;- st.native_to_ascii = defaults.native_to_ascii_for(&st.path);+ let loaded = if force_clean {+ Self::load_as(&st.path, &st.encoding, st.native_to_ascii)?+ } else {+ let defaults = self.file_defaults();+ let loaded = Self::load_with_defaults(&st.path, &defaults)?;+ st.native_to_ascii = defaults.native_to_ascii_for(&st.path);+ loaded+ };st.disk_mtime = loaded.mtime_ms;st.disk_len = disk_len(&st.path);if loaded.binary || st.binary {diff --git a/crates/ide-workspace/tests/documents.rs b/crates/ide-workspace/tests/documents.rsindex 02370eed5..16670ce1e 100644--- a/crates/ide-workspace/tests/documents.rs+++ b/crates/ide-workspace/tests/documents.rs@@ -57,6 +57,37 @@ fn fixture() -> Fixture {Fixture { _tmp: tmp, root, docs, events, rec }}+#[test]+fn own_disk_changes_preserve_the_open_documents_encoding() {+ let f = fixture();+ let path = f.root.join("query.sql");+ let original = "SELECT '中文';\r\n";+ fs::write(&path, ide_vfs::encode(original, "gbk", false).unwrap()).unwrap();+ let mut defaults = f.docs.file_defaults();+ defaults.project_fallback = "gbk".into();+ f.docs.set_file_defaults(defaults.clone());+ let doc = f.docs.open(&path).unwrap();+ assert_eq!(doc.encoding, "gbk");+ defaults.project_fallback = "windows-1252".into();+ f.docs.set_file_defaults(defaults);+ f.docs.sync_after_disk_change();+ let unchanged = f.docs.snapshot(doc.id).unwrap();+ assert_eq!(unchanged.text, doc.text);+ assert_eq!(unchanged.encoding, "gbk");+ assert!(!unchanged.dirty);+ let changed = "SELECT '世界';\r\n";+ let bytes = ide_vfs::encode(changed, "gbk", false).unwrap();+ fs::write(&path, &bytes).unwrap();+ f.docs.sync_after_disk_change();+ let reloaded = f.docs.snapshot(doc.id).unwrap();+ assert_eq!(reloaded.text, changed.replace("\r\n", "\n"));+ assert_eq!(reloaded.encoding, "gbk");+ assert_eq!(reloaded.line_ending, LineEnding::CrLf);+ assert!(!reloaded.dirty);+ f.docs.save_all().unwrap();+ assert_eq!(fs::read(&path).unwrap(), bytes);+}+fn change(from: u32, to: u32, insert: &str) -> ChangeSet {ChangeSet { changes: vec![TextChange { from, to, insert: insert.into() }] }}diff --git a/src/editor/api.ts b/src/editor/api.tsindex 671f0d9bc..fb5554b03 100644--- a/src/editor/api.ts+++ b/src/editor/api.ts@@ -433,7 +433,7 @@ export function _emitEditorEvent(e: EditorEvent) {// --- save participants ----------------------------------------------------------/**- * Runs before a document is written (format on save, organise imports…).+ * Runs before a modified document is written (format on save, organise imports…).* Participants may edit the document through `handle.view` (normal* transactions); editor/core waits for them, then trims whitespace / adds the* final newline per settings, flushes the edit pipeline and saves. `handle`diff --git a/src/editor/core/model/document.test.ts b/src/editor/core/model/document.test.tsindex 6ee9a7d91..1b066027e 100644--- a/src/editor/core/model/document.test.ts+++ b/src/editor/core/model/document.test.ts@@ -1,7 +1,7 @@import { afterEach, describe, expect, it, vi } from "vitest";import { EditorState } from "@codemirror/state";import { language as languageFacet } from "@codemirror/language";-import { remoteChange } from "@/editor/api";+import { registerSaveParticipant, remoteChange } from "@/editor/api";import { createMemoryBackend, type MemoryBackend } from "../backend";import { _resetLanguages } from "../cm/languages";import { DocumentManager, ModifiedRanges, saveCleanupChanges, useDocMeta } from "./document";@@ -88,6 +88,60 @@ describe("DocumentManager + slots", () => {expect(useDocMeta.getState()["/p/a.txt"]?.dirty).toBe(false);});+ it.each(["explicit", "auto"] as const)(+ "%s save leaves untouched documents byte-for-byte unchanged",+ async (reason) => {+ const files = {+ "/p/src/main/resources/sql/no-final.sql": "SELECT *\nFROM patients\n\tLIMIT 10 OFFSET 0",+ "/p/trailing.sql": "SELECT id \nFROM patients;\t \n",+ "/p/crlf.sql": "SELECT id\r\nFROM patients;\r\n",+ "/p/Untouched.java": "class Untouched { \n\tint id;\n}",+ "/p/blank.sql": "SELECT 1;\n\n\n",+ "/p/edited.java": "class Edited {}\n",+ };+ const { backend, manager } = setup(files, {+ editor: { general: { stripTrailingScope: "all", removeTrailingBlankLines: true } },+ });+ const participant = vi.fn();+ const unregister = registerSaveParticipant({ id: "test.save", beforeSave: participant });+ const save = vi.spyOn(backend, "save");+ try {+ const slots = [];+ for (const path of Object.keys(files)) slots.push(new EditorSlot(await manager.acquire(path), path, host));+ const edited = slots.at(-1)!;+ edited.dispatchLocal({ changes: { from: 0, insert: "// edited\n" } });+ await manager.saveAll(reason);+ for (const [path, text] of Object.entries(files)) {+ if (path !== "/p/edited.java") expect(backend.files.get(path), path).toBe(text);+ }+ expect(backend.files.get("/p/edited.java")).toBe("// edited\nclass Edited {}\n");+ expect(save.mock.calls).toEqual([[edited.model.doc]]);+ expect(participant).toHaveBeenCalledTimes(reason === "explicit" ? 1 : 0);+ if (reason === "explicit") expect(participant.mock.calls[0]![0].path).toBe("/p/edited.java");+ await manager.saveAll(reason);+ expect(save).toHaveBeenCalledTimes(1);+ } finally {+ unregister();+ manager.stop();+ }+ },+ );++ it("checks dirty state when each queued save starts", async () => {+ const { backend, manager } = setup({ "/p/query.sql": "SELECT 1" });+ const model = await manager.acquire("/p/query.sql");+ const slot = new EditorSlot(model, "t1", host);+ slot.dispatchLocal({ changes: { from: 7, to: 8, insert: "2" } });+ const save = vi.spyOn(backend, "save");+ try {+ await Promise.all([model.save("explicit"), model.save("explicit"), model.save("auto")]);+ expect(backend.files.get(model.path)).toBe("SELECT 2\n");+ expect(save).toHaveBeenCalledTimes(1);+ } finally {+ manager.stop();+ }+ });+it("closes the backend document when the last slot goes away", async () => {const { backend, manager } = setup({ "/p/a.txt": "x" });const model = await manager.acquire("/p/a.txt");diff --git a/src/editor/core/model/document.ts b/src/editor/core/model/document.tsindex 9c70e8f61..a6bd1f182 100644--- a/src/editor/core/model/document.ts+++ b/src/editor/core/model/document.ts@@ -569,8 +569,7 @@ export class DocModel {save(reason: "explicit" | "auto"): Promise<void> {const run = async () => {- if (this.closed || this.meta.readOnly) return;- if (reason === "auto" && !this.meta.dirty) return;+ if (this.closed || this.meta.readOnly || !this.meta.dirty) return;const slot = this.primarySlot();if (reason === "explicit") {for (const p of _saveParticipants()) {@@ -764,7 +763,7 @@ export class DocumentManager {for (const m of this.byPath.values()) m.applySettings();}- /** Saves every document; failures are notified, and an explicit Save All also rejects with them. */+ /** Saves dirty documents; failures are notified, and an explicit Save All also rejects with them. */async saveAll(reason: "explicit" | "auto") {const errors: unknown[] = [];await Promise.all(