Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Properly deduplicate overlapping range formatting results (#62935)
Kirill Bulatovdeb194b49b34
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rsindex 062c869d788..2246b2bddd4 100644--- a/crates/editor/src/editor_tests.rs+++ b/crates/editor/src/editor_tests.rs@@ -16228,160 +16228,6 @@ async fn test_autosave_with_dirty_buffers(cx: &mut TestAppContext) {);}-async fn setup_range_format_test_with_capabilities(- cx: &mut TestAppContext,- capabilities: lsp::ServerCapabilities,-) -> (- Entity<Project>,- Entity<Editor>,- &mut gpui::VisualTestContext,- lsp::FakeLanguageServer,-) {- init_test(cx, |_| {});-- let fs = FakeFs::new(cx.executor());- fs.insert_file(path!("/file.rs"), Default::default()).await;-- let project = Project::test(fs, [path!("/").as_ref()], cx).await;-- let language_registry = project.read_with(cx, |project, _| project.languages().clone());- language_registry.add(rust_lang());- let mut fake_servers = language_registry.register_fake_lsp(- "Rust",- FakeLspAdapter {- capabilities,- ..FakeLspAdapter::default()- },- );-- let buffer = project- .update(cx, |project, cx| {- project.open_local_buffer(path!("/file.rs"), cx)- })- .await- .unwrap();-- let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));- let (editor, cx) = cx.add_window_view(|window, cx| {- build_editor_with_project(project.clone(), buffer, window, cx)- });- editor.update_in(cx, |editor, window, cx| {- window.focus(&editor.focus_handle(cx), cx);- });-- let fake_server = fake_servers.next().await.unwrap();-- (project, editor, cx, fake_server)-}--async fn setup_range_format_test(- cx: &mut TestAppContext,-) -> (- Entity<Project>,- Entity<Editor>,- &mut gpui::VisualTestContext,- lsp::FakeLanguageServer,-) {- setup_range_format_test_with_capabilities(- cx,- lsp::ServerCapabilities {- document_range_formatting_provider: Some(lsp::OneOf::Left(true)),- ..lsp::ServerCapabilities::default()- },- )- .await-}--/// Like `setup_range_format_test`, but backs the buffer with a FakeFs git-/// repository so that `GitStore::get_unstaged_diff` returns a real diff.-/// `head_content` sets the HEAD base, `index_content` sets the staged base.-/// The buffer starts empty; the caller must `editor.set_text(...)` to set the-/// working-tree content (the diff recomputes from buffer changes).-async fn setup_range_format_test_with_git<'a>(- cx: &'a mut TestAppContext,- head_content: &str,- index_content: &str,-) -> (- Entity<Project>,- Entity<Editor>,- &'a mut gpui::VisualTestContext,- lsp::FakeLanguageServer,-) {- init_test(cx, |_| {});-- let fs = FakeFs::new(cx.executor());- fs.insert_tree(- path!("/project"),- json!({- ".git": {},- "file.rs": "",- }),- )- .await;-- fs.set_head_for_repo(- std::path::Path::new(path!("/project/.git")),- &[("file.rs", head_content.to_string())],- "deadbeef",- );- fs.set_index_for_repo(- std::path::Path::new(path!("/project/.git")),- &[("file.rs", index_content.to_string())],- );-- let project = Project::test(fs, [path!("/project").as_ref()], cx).await;-- let language_registry = project.read_with(cx, |project, _| project.languages().clone());- language_registry.add(rust_lang());- let mut fake_servers = language_registry.register_fake_lsp(- "Rust",- FakeLspAdapter {- capabilities: lsp::ServerCapabilities {- document_range_formatting_provider: Some(lsp::OneOf::Left(true)),- document_formatting_provider: Some(lsp::OneOf::Left(true)),- ..lsp::ServerCapabilities::default()- },- ..FakeLspAdapter::default()- },- );-- let buffer = project- .update(cx, |project, cx| {- project.open_local_buffer(path!("/project/file.rs"), cx)- })- .await- .unwrap();-- // Open the unstaged diff so GitStore tracks this buffer. Without this,- // `get_unstaged_diff` returns None and compute_format_target cannot- // produce range-based FormatTarget.- project- .update(cx, |project, cx| {- project.open_unstaged_diff(buffer.clone(), cx)- })- .await- .unwrap();-- let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));- let (editor, cx) = cx.add_window_view(|window, cx| {- build_editor_with_project(project.clone(), buffer, window, cx)- });- editor.update_in(cx, |editor, window, cx| {- window.focus(&editor.focus_handle(cx), cx);- });-- let fake_server = fake_servers.next().await.unwrap();-- (project, editor, cx, fake_server)-}--fn refresh_editor_actions(cx: &mut VisualTestContext) {- cx.executor().run_until_parked();- cx.update(|window, cx| {- let _ = window.draw(cx);- });-}-#[gpui::test]async fn test_format_selections_action_available_when_range_formatting_is_supported(cx: &mut TestAppContext,@@ -16901,6 +16747,129 @@ async fn test_modifications_format_multiple_hunks(cx: &mut TestAppContext) {assert!(!cx.read(|cx| editor.is_dirty(cx)));}+#[gpui::test]+async fn test_modifications_format_overlapping_range_responses(cx: &mut TestAppContext) {+ assert_range_format_merge(+ cx,+ "line0\nline1\nline2\nline3\nline4\nline5\n",+ "line0\nLINE1\nline2\nline3\nLINE4\nline5\n",+ vec![vec![lsp_line_edit(0, 6, "fmt0\nfmt1\nfmt2\nfmt3\nfmt4\nfmt5\n")]],+ "fmt0\nfmt1\nfmt2\nfmt3\nfmt4\nfmt5\n",+ "a response covering the second hunk must suppress its request and must not duplicate the formatted block",+ )+ .await;+}++#[gpui::test]+async fn test_modifications_format_divergent_overlapping_responses(cx: &mut TestAppContext) {+ assert_range_format_merge(+ cx,+ "line0\nline1\nline2\nline3\nline4\nline5\n",+ "line0\nLINE1\nline2\nline3\nLINE4\nline5\n",+ vec![+ vec![lsp_line_edit(1, 3, "one\ntwo\n")],+ vec![lsp_line_edit(2, 5, "TWO\nthree\nfour\n")],+ ],+ "line0\none\ntwo\nline3\nLINE4\nline5\n",+ "the first edit must win and the divergent overlapping edit must be dropped without corrupting the buffer",+ )+ .await;+}++#[gpui::test]+async fn test_modifications_format_partially_overlapping_response_dropped_atomically(+ cx: &mut TestAppContext,+) {+ assert_range_format_merge(+ cx,+ "line0\nline1\nline2\nline3\nline4\nline5\n",+ "line0\nLINE1\nline2\nline3\nLINE4\nline5\n",+ vec![+ vec![lsp_line_edit(1, 2, "one\n")],+ vec![+ lsp_line_edit(4, 5, "four\n"),+ lsp_line_edit(1, 2, "ONE\n"),+ ],+ ],+ "line0\none\nline2\nline3\nLINE4\nline5\n",+ "a response with any divergent overlapping edit must be dropped whole, including its non-overlapping edits",+ )+ .await;+}++#[gpui::test]+async fn test_modifications_format_overlapping_edits_within_one_response(cx: &mut TestAppContext) {+ assert_range_format_merge(+ cx,+ "line0\nline1\nline2\nline3\nline4\nline5\n",+ "line0\nLINE1\nline2\nline3\nline4\nline5\n",+ vec![vec![+ lsp_line_edit(1, 2, "one\n"),+ lsp_line_edit(1, 2, "uno\n"),+ ]],+ "line0\none\nline2\nline3\nline4\nline5\n",+ "the later overlapping edit within one response must be dropped",+ )+ .await;+}++#[gpui::test]+async fn test_modifications_format_same_position_inserts_within_one_response(+ cx: &mut TestAppContext,+) {+ assert_range_format_merge(+ cx,+ "line0\nline1\nline2\n",+ "line0\nLINE1\nline2\n",+ vec![vec![+ lsp_line_edit(1, 1, "alpha\n"),+ lsp_line_edit(1, 1, "beta\n"),+ ]],+ "line0\nalpha\nbeta\nLINE1\nline2\n",+ "multiple inserts at one position within one response are valid per the LSP spec and must all apply in array order",+ )+ .await;+}++#[gpui::test]+async fn test_modifications_format_divergent_same_position_inserts_across_responses(+ cx: &mut TestAppContext,+) {+ assert_range_format_merge(+ cx,+ "line0\nline1\nline2\nline3\nline4\nline5\n",+ "line0\nLINE1\nline2\nline3\nLINE4\nline5\n",+ vec![+ vec![lsp_line_edit(4, 4, "alpha\n")],+ vec![lsp_line_edit(4, 4, "beta\n")],+ ],+ "line0\nLINE1\nline2\nline3\nalpha\nLINE4\nline5\n",+ "a later response inserting different text at the same position diverges and must be dropped",+ )+ .await;+}++#[gpui::test]+async fn test_modifications_format_insert_touching_kept_edit_across_responses(+ cx: &mut TestAppContext,+) {+ assert_range_format_merge(+ cx,+ "line0\nline1\nline2\nline3\nline4\nline5\n",+ "line0\nLINE1\nline2\nline3\nLINE4\nline5\n",+ vec![+ vec![+ lsp_line_edit(1, 2, "one\n"),+ lsp_line_edit(4, 4, "alpha\n"),+ ],+ vec![lsp_line_edit(4, 5, "alpha\nfour\n")],+ ],+ "line0\none\nline2\nline3\nalpha\nLINE4\nline5\n",+ "an edit touching a kept insert at its boundary can duplicate the inserted text and must be dropped as divergent",+ )+ .await;+}+#[gpui::test]async fn test_modifications_format_excludes_staged_changes(cx: &mut TestAppContext) {let head_content = "line0\nline1\nline2\nline3\nline4\n";@@ -43435,3 +43404,242 @@ async fn test_in_preview_key_context(cx: &mut TestAppContext) {);});}++async fn setup_range_format_test_with_capabilities(+ cx: &mut TestAppContext,+ capabilities: lsp::ServerCapabilities,+) -> (+ Entity<Project>,+ Entity<Editor>,+ &mut gpui::VisualTestContext,+ lsp::FakeLanguageServer,+) {+ init_test(cx, |_| {});++ let fs = FakeFs::new(cx.executor());+ fs.insert_file(path!("/file.rs"), Default::default()).await;++ let project = Project::test(fs, [path!("/").as_ref()], cx).await;++ let language_registry = project.read_with(cx, |project, _| project.languages().clone());+ language_registry.add(rust_lang());+ let mut fake_servers = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ capabilities,+ ..FakeLspAdapter::default()+ },+ );++ let buffer = project+ .update(cx, |project, cx| {+ project.open_local_buffer(path!("/file.rs"), cx)+ })+ .await+ .unwrap();++ let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));+ let (editor, cx) = cx.add_window_view(|window, cx| {+ build_editor_with_project(project.clone(), buffer, window, cx)+ });+ editor.update_in(cx, |editor, window, cx| {+ window.focus(&editor.focus_handle(cx), cx);+ });++ let fake_server = fake_servers.next().await.unwrap();++ (project, editor, cx, fake_server)+}++async fn setup_range_format_test(+ cx: &mut TestAppContext,+) -> (+ Entity<Project>,+ Entity<Editor>,+ &mut gpui::VisualTestContext,+ lsp::FakeLanguageServer,+) {+ setup_range_format_test_with_capabilities(+ cx,+ lsp::ServerCapabilities {+ document_range_formatting_provider: Some(lsp::OneOf::Left(true)),+ ..lsp::ServerCapabilities::default()+ },+ )+ .await+}++/// Like `setup_range_format_test`, but backs the buffer with a FakeFs git+/// repository so that `GitStore::get_unstaged_diff` returns a real diff.+/// `head_content` sets the HEAD base, `index_content` sets the staged base.+/// The buffer starts empty; the caller must `editor.set_text(...)` to set the+/// working-tree content (the diff recomputes from buffer changes).+async fn setup_range_format_test_with_git<'a>(+ cx: &'a mut TestAppContext,+ head_content: &str,+ index_content: &str,+) -> (+ Entity<Project>,+ Entity<Editor>,+ &'a mut gpui::VisualTestContext,+ lsp::FakeLanguageServer,+) {+ init_test(cx, |_| {});++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/project"),+ json!({+ ".git": {},+ "file.rs": "",+ }),+ )+ .await;++ fs.set_head_for_repo(+ std::path::Path::new(path!("/project/.git")),+ &[("file.rs", head_content.to_string())],+ "deadbeef",+ );+ fs.set_index_for_repo(+ std::path::Path::new(path!("/project/.git")),+ &[("file.rs", index_content.to_string())],+ );++ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;++ let language_registry = project.read_with(cx, |project, _| project.languages().clone());+ language_registry.add(rust_lang());+ let mut fake_servers = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ capabilities: lsp::ServerCapabilities {+ document_range_formatting_provider: Some(lsp::OneOf::Left(true)),+ document_formatting_provider: Some(lsp::OneOf::Left(true)),+ ..lsp::ServerCapabilities::default()+ },+ ..FakeLspAdapter::default()+ },+ );++ let buffer = project+ .update(cx, |project, cx| {+ project.open_local_buffer(path!("/project/file.rs"), cx)+ })+ .await+ .unwrap();++ // Open the unstaged diff so GitStore tracks this buffer. Without this,+ // `get_unstaged_diff` returns None and compute_format_target cannot+ // produce range-based FormatTarget.+ project+ .update(cx, |project, cx| {+ project.open_unstaged_diff(buffer.clone(), cx)+ })+ .await+ .unwrap();++ let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));+ let (editor, cx) = cx.add_window_view(|window, cx| {+ build_editor_with_project(project.clone(), buffer, window, cx)+ });+ editor.update_in(cx, |editor, window, cx| {+ window.focus(&editor.focus_handle(cx), cx);+ });++ let fake_server = fake_servers.next().await.unwrap();++ (project, editor, cx, fake_server)+}++fn refresh_editor_actions(cx: &mut VisualTestContext) {+ cx.executor().run_until_parked();+ cx.update(|window, cx| {+ let _ = window.draw(cx);+ });+}++fn lsp_line_edit(start_line: u32, end_line: u32, text: &str) -> lsp::TextEdit {+ lsp::TextEdit::new(+ lsp::Range::new(+ lsp::Position::new(start_line, 0),+ lsp::Position::new(end_line, 0),+ ),+ text.to_string(),+ )+}++async fn assert_range_format_merge(+ cx: &mut TestAppContext,+ head_content: &str,+ buffer_text: &str,+ responses: Vec<Vec<lsp::TextEdit>>,+ expected_text: &str,+ description: &str,+) {+ let expected_requests = responses.len();+ let (project, editor, cx, fake_server) =+ setup_range_format_test_with_git(cx, head_content, head_content).await;++ update_test_language_settings(cx, &|settings| {+ settings.defaults.format_on_save = Some(FormatOnSave::Modifications);+ });++ editor.update_in(cx, |editor, window, cx| {+ editor.set_text(buffer_text, window, cx);+ });+ cx.run_until_parked();+ assert!(cx.read(|cx| editor.is_dirty(cx)));++ let request_count = Arc::new(AtomicUsize::new(0));+ let responses = Arc::new(responses);+ let mut responded_rx =+ fake_server.set_request_handler::<lsp::request::RangeFormatting, _, _>({+ let request_count = request_count.clone();+ move |params, _| {+ let count = request_count.fetch_add(1, atomic::Ordering::SeqCst);+ let responses = responses.clone();+ async move {+ assert_eq!(+ params.text_document.uri,+ lsp::Uri::from_file_path(path!("/project/file.rs")).unwrap()+ );+ match responses.get(count) {+ Some(edits) => Ok(Some(edits.clone())),+ None => panic!("unexpected range formatting request #{}", count + 1),+ }+ }+ }+ });++ let save = editor+ .update_in(cx, |editor, window, cx| {+ editor.save(+ SaveOptions {+ format: true,+ autosave: false,+ force_format: false,+ },+ project.clone(),+ window,+ cx,+ )+ })+ .unwrap();+ for _ in 0..expected_requests {+ responded_rx.next().await;+ }+ save.await;++ assert_eq!(+ request_count.load(atomic::Ordering::SeqCst),+ expected_requests,+ "{description}"+ );+ assert_eq!(+ editor.update(cx, |editor, cx| editor.text(cx)),+ expected_text,+ "{description}"+ );+ assert!(!cx.read(|cx| editor.is_dirty(cx)));+}diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rsindex 0c06cbf08d4..c152a8832ef 100644--- a/crates/project/src/lsp_store.rs+++ b/crates/project/src/lsp_store.rs@@ -2424,9 +2424,20 @@ impl LocalLspStore {anyhow::Ok(())})??;- let mut edits = None;+ let mut edits = None::<Vec<lsp::TextEdit>>;for range in lsp_ranges {- if let Some(mut edit) = language_server+ if edits.as_ref().is_some_and(|edits| {+ edits+ .iter()+ .any(|kept| kept.range.start <= range.start && range.end <= kept.range.end)+ }) {+ log::debug!(+ "language server {}: skipping range formatting request for {range:?}: an earlier response already covers it",+ language_server.name()+ );+ continue;+ }+ if let Some(range_edits) = language_server.request::<lsp::request::RangeFormatting>(lsp::DocumentRangeFormattingParams {text_document: text_document.clone(),@@ -2439,7 +2450,50 @@ impl LocalLspStore {.await.into_response()?{- edits.get_or_insert_with(Vec::new).append(&mut edit);+ let kept_edits = edits.get_or_insert_with(Vec::new);+ let mut new_edits = Vec::new();+ let mut overlaps_earlier_response = false;+ for edit in range_edits {+ let is_duplicate = kept_edits+ .iter()+ .any(|kept| kept.range == edit.range && kept.new_text == edit.new_text);+ if is_duplicate {+ continue;+ }+ if kept_edits+ .iter()+ .any(|kept| lsp_ranges_conflict(&edit.range, &kept.range))+ {+ overlaps_earlier_response = true;+ break;+ }+ new_edits.push(edit);+ }+ if overlaps_earlier_response {+ log::debug!(+ "language server {} returned range formatting edits for {range:?} that overlap an earlier response and differ; dropping the whole response",+ language_server.name()+ );+ continue;+ }+ let response_start = kept_edits.len();+ let mut dropped_within_response = 0_usize;+ for edit in new_edits {+ if kept_edits[response_start..]+ .iter()+ .any(|kept| lsp_ranges_overlap(&edit.range, &kept.range))+ {+ dropped_within_response += 1;+ continue;+ }+ kept_edits.push(edit);+ }+ if dropped_within_response > 0 {+ log::debug!(+ "language server {} returned overlapping edits within one range formatting response for {range:?}; dropped {dropped_within_response} later edit(s)",+ language_server.name()+ );+ }}}edits@@ -3381,7 +3435,7 @@ impl LocalLspStore {}).collect::<Vec<_>>();- lsp_edits.sort_unstable_by_key(|(range, _)| (range.start, range.end));+ lsp_edits.sort_by_key(|(range, _)| (range.start, range.end));let mut lsp_edits = lsp_edits.into_iter().peekable();let mut edits = Vec::new();@@ -13680,6 +13734,18 @@ fn server_capabilities_support_range_formatting(capabilities: &lsp::ServerCapabi)}+fn lsp_ranges_conflict(a: &lsp::Range, b: &lsp::Range) -> bool {+ if a.start == a.end || b.start == b.end {+ a.start <= b.end && b.start <= a.end+ } else {+ lsp_ranges_overlap(a, b)+ }+}++fn lsp_ranges_overlap(a: &lsp::Range, b: &lsp::Range) -> bool {+ a.start < b.end && b.start < a.end+}+fn subscribe_to_binary_statuses(languages: &Arc<LanguageRegistry>,cx: &mut Context<'_, LspStore>,