From b9f3396b68c61e27f2aab38fbe4bcd274968befa Mon Sep 17 00:00:00 2001
From: G36maid <53391375+G36maid@users.noreply.github.com>
Date: Thu, 9 Jul 2026 00:53:11 +0800
Subject: [PATCH] Add support for `format_on_save` only changed lines (#49964)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
## Summary
Introduces `format_on_save` variants that format only modified lines,
limiting formatting to lines changed since the last commit. This
prevents massive diffs when editing legacy codebases. Aligns with VS
Code's `editor.formatOnSaveMode` naming:
- `"modifications"` — formats only git-diffed lines. Requires source
control; skips formatting if no diff is available.
- `"modifications_if_available"` — formats only git-diffed lines,
falling back to full-file formatting for untracked files, when source
control is unavailable, or when the LSP does not support range
formatting.
Also supports importing equivalent VS Code settings
(`formatOnSaveMode`).
This PR uses the range-based whitespace/newline infrastructure from the
dependency PR above.
## Changes
New settings, modified ranges computation, VS Code
import
### New settings (`language.rs`, `default.json`, `all-settings.md`)
Two new `FormatOnSave` variants: `Modifications` and
`ModificationsIfAvailable`.
### Modified ranges computation (`items.rs`)
- `compute_format_decision()` — reads `format_on_save` setting across
all buffers, determines whether to use ranged formatting (`Ranges`),
full formatting (`Full`), or skip (`Skip`).
- `compute_modified_ranges()` — extracts modified line ranges from git
diff hunks via `BufferDiffSnapshot`.
- `is_empty_range()` — helper to detect deletion-only hunks that produce
no formatable content.
The `save()` method calls `compute_format_decision()` and dispatches
accordingly.
### Modifications mode in `lsp_store.rs`
- Adds `FormatOnSave::Modifications |
FormatOnSave::ModificationsIfAvailable` to the formatter selection match
arm.
- `ModificationsIfAvailable` falls back to full-file formatting when
ranged formatting produces no results.
### VS Code settings import (`vscode_import.rs`, `settings_store.rs`)
Imports `editor.formatOnSaveMode` mapping:
- `"modifications"` → `FormatOnSave::Modifications`
- `"modificationsIfAvailable"` →
`FormatOnSave::ModificationsIfAvailable`
- `"file"` → `FormatOnSave::On`
## Tests
- `test_modifications_format_on_save` — basic modifications mode
formatting with dirty buffer
- `test_modifications_format_no_changes` — clean buffer triggers no
formatting
- `test_modifications_format_lsp_no_range_support` — LSP without range
formatting skips entirely for `Modifications`
- `test_modifications_format_lsp_returns_empty_edits` — empty edits
handled gracefully
- `test_modifications_format_multiple_hunks` — two non-adjacent edits
produce two separate range formatting requests
---
Self-Review Checklist:
- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable
Closes #16509
Depends on #53942
Release Notes:
- Added `modifications` and `modifications_if_available` options to
`format_on_save`, which format only git-changed lines instead of the
entire file
- When using modifications mode, `remove_trailing_whitespace_on_save`
and `ensure_final_newline_on_save` are also scoped to changed lines,
preventing unwanted diff jitter in legacy codebases
- Added support for importing VS Code's `editor.formatOnSaveMode`
setting
---------
Co-authored-by: Kirill Bulatov
---
assets/settings/default.json | 8 +-
crates/editor/src/editor_tests.rs | 1020 ++++++++++++++++-
crates/editor/src/items.rs | 258 ++++-
.../src/migrations/m_2025_10_02/settings.rs | 6 +-
crates/project/src/lsp_store.rs | 57 +-
crates/settings/src/settings_store.rs | 142 +++
crates/settings/src/vscode_import.rs | 12 +-
crates/settings_content/src/language.rs | 12 +-
crates/settings_ui/src/page_data.rs | 2 +-
docs/src/reference/all-settings.md | 24 +-
10 files changed, 1507 insertions(+), 34 deletions(-)
diff --git a/assets/settings/default.json b/assets/settings/default.json
index 983784e8951..0e42d27e980 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1458,7 +1458,13 @@
// The EditorConfig `end_of_line` property overrides this setting and behaves
// like `enforce_lf` or `enforce_crlf`.
"line_ending": "detect",
- // Whether or not to perform a buffer format before saving: [on, off]
+ // Whether or not to perform a buffer format before saving:
+ // "on" — format the whole buffer
+ // "off" — do not format
+ // "modifications" — format only lines with unstaged changes; skips formatting
+ // when no git diff is available or the language server lacks range formatting
+ // "modifications_if_available" — same, but falls back to formatting the whole
+ // buffer when range formatting cannot be used
// Keep in mind, if the autosave with delay is enabled, format_on_save will be ignored
"format_on_save": "off",
// How to perform a buffer format. This setting can take multiple values:
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index ca5cc9a6a2f..9b78a9a5c0c 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -29,7 +29,8 @@ use language::{
LanguageConfig, LanguageConfigOverride, LanguageMatcher, LanguageName, LanguageQueries,
LanguageToolchainStore, Override, Point,
language_settings::{
- CompletionSettingsContent, FormatterList, LanguageSettingsContent, LspInsertMode,
+ CompletionSettingsContent, FormatOnSave, FormatterList, LanguageSettingsContent,
+ LspInsertMode,
},
tree_sitter_python,
};
@@ -15171,6 +15172,89 @@ async fn setup_range_format_test(
.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,
+ Entity,
+ &'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| {
@@ -15383,6 +15467,940 @@ async fn test_range_format_on_save_timeout(cx: &mut TestAppContext) {
assert!(!cx.read(|cx| editor.is_dirty(cx)));
}
+#[gpui::test]
+async fn test_modifications_format_on_save(cx: &mut TestAppContext) {
+ let (project, editor, cx, fake_server) = setup_range_format_test_with_git(cx, "", "").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("one\ntwo\nthree\n", window, cx)
+ });
+ cx.run_until_parked();
+ assert!(cx.read(|cx| editor.is_dirty(cx)));
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ fake_server
+ .set_request_handler::(move |params, _| async move {
+ assert_eq!(
+ params.text_document.uri,
+ lsp::Uri::from_file_path(path!("/project/file.rs")).unwrap()
+ );
+ Ok(Some(vec![lsp::TextEdit::new(
+ lsp::Range::new(lsp::Position::new(0, 3), lsp::Position::new(1, 0)),
+ ", ".to_string(),
+ )]))
+ })
+ .next()
+ .await;
+ save.await;
+ assert_eq!(
+ editor.update(cx, |editor, cx| editor.text(cx)),
+ "one, two\nthree\n"
+ );
+ assert!(!cx.read(|cx| editor.is_dirty(cx)));
+}
+
+#[gpui::test]
+async fn test_modifications_format_skips_without_git_diff(cx: &mut TestAppContext) {
+ let (project, editor, cx, fake_server) = setup_range_format_test(cx).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("one\ntwo\nthree\n", window, cx)
+ });
+ assert!(
+ cx.read(|cx| editor.is_dirty(cx)),
+ "editor should be dirty before save"
+ );
+
+ let _no_range_format_handler = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("rangeFormatting must not be called when no git diff is available");
+ })
+ .next();
+ let _no_format_handler = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("full formatting must not be called for Modifications without a git diff");
+ })
+ .next();
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ save.await;
+ cx.run_until_parked();
+ assert!(
+ !cx.read(|cx| editor.is_dirty(cx)),
+ "the buffer should be saved despite the skipped formatting"
+ );
+ assert_eq!(
+ editor.update(cx, |editor, cx| editor.text(cx)),
+ "one\ntwo\nthree\n"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_format_lsp_no_range_support(cx: &mut TestAppContext) {
+ init_test(cx, |_| {});
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/project"),
+ json!({
+ ".git": {},
+ "file.rs": "",
+ }),
+ )
+ .await;
+
+ let head_content = "one\ntwo\nthree\n";
+ fs.set_head_and_index_for_repo(
+ std::path::Path::new(path!("/project/.git")),
+ &[("file.rs", head_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(false)),
+ 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();
+ 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)
+ });
+
+ let fake_server = fake_servers.next().await.unwrap();
+
+ update_test_language_settings(cx, &|settings| {
+ settings.defaults.format_on_save = Some(FormatOnSave::Modifications);
+ });
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text("one\nTWO\nthree\n", window, cx)
+ });
+ cx.run_until_parked();
+ assert!(cx.read(|cx| editor.is_dirty(cx)));
+
+ let _no_range_format_handler = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("rangeFormatting must not be called when range formatting is unsupported");
+ })
+ .next();
+ let _no_format_handler = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("full formatting must not be called for Modifications when range formatting is unsupported");
+ })
+ .next();
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ save.await;
+ cx.run_until_parked();
+ assert!(!cx.read(|cx| editor.is_dirty(cx)));
+ assert_eq!(
+ editor.update(cx, |editor, cx| editor.text(cx)),
+ "one\nTWO\nthree\n"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_format_lsp_returns_empty_edits(cx: &mut TestAppContext) {
+ let (project, editor, cx, fake_server) = setup_range_format_test_with_git(cx, "", "").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("aaa\nbbb\nccc\nddd\neee\n", window, cx)
+ });
+ cx.run_until_parked();
+ assert!(cx.read(|cx| editor.is_dirty(cx)));
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ fake_server
+ .set_request_handler::(move |params, _| async move {
+ assert_eq!(
+ params.text_document.uri,
+ lsp::Uri::from_file_path(path!("/project/file.rs")).unwrap()
+ );
+ Ok(Some(Vec::new()))
+ })
+ .next()
+ .await;
+ save.await;
+ assert!(!cx.read(|cx| editor.is_dirty(cx)));
+ assert_eq!(
+ editor.update(cx, |editor, cx| editor.text(cx)),
+ "aaa\nbbb\nccc\nddd\neee\n"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_format_multiple_hunks(cx: &mut TestAppContext) {
+ let head_content = "line0\nline1\nline2\nline3\nline4\nline5\n";
+ 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("line0\nLINE1\nline2\nline3\nLINE4\nline5\n", window, cx);
+ });
+ cx.run_until_parked();
+ assert!(cx.read(|cx| editor.is_dirty(cx)));
+
+ let request_count = Arc::new(AtomicUsize::new(0));
+ let request_count_clone = request_count.clone();
+ let mut responded_rx =
+ fake_server.set_request_handler::(move |params, _| {
+ let count = request_count_clone.fetch_add(1, atomic::Ordering::SeqCst);
+ async move {
+ assert_eq!(
+ params.text_document.uri,
+ lsp::Uri::from_file_path(path!("/project/file.rs")).unwrap()
+ );
+ match count {
+ 0 => Ok(Some(vec![lsp::TextEdit::new(
+ lsp::Range::new(lsp::Position::new(1, 5), lsp::Position::new(1, 5)),
+ "!".to_string(),
+ )])),
+ 1 => Ok(Some(vec![lsp::TextEdit::new(
+ lsp::Range::new(lsp::Position::new(4, 5), lsp::Position::new(4, 5)),
+ "!".to_string(),
+ )])),
+ _ => panic!("unexpected third range formatting request"),
+ }
+ }
+ });
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ responded_rx.next().await;
+ responded_rx.next().await;
+ save.await;
+
+ assert_eq!(request_count.load(atomic::Ordering::SeqCst), 2);
+ assert_eq!(
+ editor.update(cx, |editor, cx| editor.text(cx)),
+ "line0\nLINE1!\nline2\nline3\nLINE4!\nline5\n"
+ );
+ assert!(!cx.read(|cx| editor.is_dirty(cx)));
+}
+
+#[gpui::test]
+async fn test_modifications_format_excludes_staged_changes(cx: &mut TestAppContext) {
+ let head_content = "line0\nline1\nline2\nline3\nline4\n";
+ let staged_content = "line0\nLINE1\nline2\nline3\nline4\n";
+ let (project, editor, cx, fake_server) =
+ setup_range_format_test_with_git(cx, head_content, staged_content).await;
+
+ update_test_language_settings(cx, &|settings| {
+ settings.defaults.format_on_save = Some(FormatOnSave::Modifications);
+ });
+
+ let working_content = "line0\nLINE1\nline2\nline3\nLINE4\n";
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text(working_content, window, cx)
+ });
+ cx.run_until_parked();
+
+ let request_count = Arc::new(AtomicUsize::new(0));
+ let request_count_clone = request_count.clone();
+ let mut responded_rx =
+ fake_server.set_request_handler::(move |params, _| {
+ request_count_clone.fetch_add(1, atomic::Ordering::SeqCst);
+ assert_eq!(
+ params.range.start.line, 4,
+ "only the unstaged hunk (LINE4) should be formatted"
+ );
+ async move { Ok(Some(Vec::new())) }
+ });
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ responded_rx.next().await;
+ save.await;
+
+ assert_eq!(
+ request_count.load(atomic::Ordering::SeqCst),
+ 1,
+ "staged hunk (LINE1) must not be formatted, only the unstaged hunk (LINE4)"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_format_range_excludes_staged_hunk(cx: &mut TestAppContext) {
+ let head_content = "a\nb\nc\n";
+ let staged_content = "A\nb\nc\n";
+ let (project, editor, cx, fake_server) =
+ setup_range_format_test_with_git(cx, head_content, staged_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("A\nB\nc\n", window, cx)
+ });
+ cx.run_until_parked();
+
+ let captured_start_line = Arc::new(AtomicUsize::new(usize::MAX));
+ let captured_start_line_clone = captured_start_line.clone();
+ let mut responded_rx =
+ fake_server.set_request_handler::(move |params, _| {
+ captured_start_line_clone
+ .store(params.range.start.line as usize, atomic::Ordering::SeqCst);
+ async move { Ok(Some(Vec::new())) }
+ });
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ responded_rx.next().await;
+ save.await;
+
+ let start_line = captured_start_line.load(atomic::Ordering::SeqCst);
+ assert_ne!(
+ start_line,
+ usize::MAX,
+ "expected at least one range formatting request"
+ );
+ assert_eq!(
+ start_line, 1,
+ "format range must exclude the staged row and start at the unstaged row"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_format_pure_unstaged_with_git(cx: &mut TestAppContext) {
+ let head_content = "line0\nline1\nline2\nline3\nline4\n";
+ 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);
+ });
+
+ let working_content = "line0\nLINE1\nline2\nline3\nLINE4\n";
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text(working_content, window, cx)
+ });
+ cx.run_until_parked();
+
+ let request_count = Arc::new(AtomicUsize::new(0));
+ let request_count_clone = request_count.clone();
+ let mut responded_rx = fake_server.set_request_handler::(
+ move |_params, _| {
+ request_count_clone.fetch_add(1, atomic::Ordering::SeqCst);
+ async move { Ok(Some(Vec::new())) }
+ },
+ );
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ responded_rx.next().await;
+ responded_rx.next().await;
+ save.await;
+
+ assert_eq!(
+ request_count.load(atomic::Ordering::SeqCst),
+ 2,
+ "unstaged hunks (LINE1, LINE4) must be formatted via the git diff path"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_format_no_unstaged_changes_with_git(cx: &mut TestAppContext) {
+ let head_content = "line0\nline1\nline2\nline3\nline4\n";
+ let staged_content = "line0\nLINE1\nline2\nline3\nLINE4\n";
+ let (project, editor, cx, fake_server) =
+ setup_range_format_test_with_git(cx, head_content, staged_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(staged_content, window, cx)
+ });
+ cx.run_until_parked();
+
+ let _no_format_handler = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("range formatting must not be called when all changes are staged");
+ })
+ .next();
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ save.await;
+ cx.run_until_parked();
+}
+
+#[gpui::test]
+async fn test_modifications_format_no_changes_with_git(cx: &mut TestAppContext) {
+ let head_content = "line0\nline1\nline2\n";
+ 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(head_content, window, cx)
+ });
+ cx.run_until_parked();
+
+ let _no_format_handler = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("range formatting must not be called when buffer matches HEAD");
+ })
+ .next();
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ save.await;
+ cx.run_until_parked();
+}
+
+#[gpui::test]
+async fn test_modifications_format_crlf_line_endings(cx: &mut TestAppContext) {
+ init_test(cx, |_| {});
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/project"),
+ json!({
+ ".git": {},
+ "file.rs": "line0\r\nline1\r\nline2\r\nline3\r\nline4\r\n",
+ }),
+ )
+ .await;
+
+ let head_content = "line0\nline1\nline2\nline3\nline4\n";
+ 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", head_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)),
+ ..lsp::ServerCapabilities::default()
+ },
+ ..FakeLspAdapter::default()
+ },
+ );
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/file.rs"), cx)
+ })
+ .await
+ .unwrap();
+
+ buffer.read_with(cx, |buffer, _| {
+ assert_eq!(
+ buffer.line_ending(),
+ language::LineEnding::Windows,
+ "buffer should detect CRLF line endings from the working tree file"
+ );
+ });
+
+ 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();
+
+ update_test_language_settings(cx, &|settings| {
+ settings.defaults.format_on_save = Some(FormatOnSave::Modifications);
+ });
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text("line0\nLINE1\nline2\nline3\nLINE4\n", window, cx)
+ });
+ cx.run_until_parked();
+
+ let request_count = Arc::new(AtomicUsize::new(0));
+ let request_count_clone = request_count.clone();
+ let mut responded_rx = fake_server.set_request_handler::(
+ move |_params, _| {
+ request_count_clone.fetch_add(1, atomic::Ordering::SeqCst);
+ async move { Ok(Some(Vec::new())) }
+ },
+ );
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ responded_rx.next().await;
+ responded_rx.next().await;
+ save.await;
+
+ assert_eq!(
+ request_count.load(atomic::Ordering::SeqCst),
+ 2,
+ "CRLF line endings must not cause spurious diff hunks"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_format_merge_boundary_one_row_gap(cx: &mut TestAppContext) {
+ let head_content = "line0\nline1\nline2\nline3\nline4\n";
+ 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);
+ });
+
+ let working_content = "line0\nLINE1\nline2\nLINE3\nline4\n";
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text(working_content, window, cx)
+ });
+ cx.run_until_parked();
+
+ let request_count = Arc::new(AtomicUsize::new(0));
+ let request_count_clone = request_count.clone();
+ let mut responded_rx = fake_server.set_request_handler::(
+ move |_params, _| {
+ request_count_clone.fetch_add(1, atomic::Ordering::SeqCst);
+ async move { Ok(Some(Vec::new())) }
+ },
+ );
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ responded_rx.next().await;
+ responded_rx.next().await;
+ save.await;
+
+ assert_eq!(
+ request_count.load(atomic::Ordering::SeqCst),
+ 2,
+ "hunks separated by exactly one unchanged row must not merge"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_if_available_empty_diff_skips_formatting(cx: &mut TestAppContext) {
+ let head_content = "line0\nline1\nline2\n";
+ 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::ModificationsIfAvailable);
+ });
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text(head_content, window, cx)
+ });
+ cx.run_until_parked();
+
+ let _no_range_format = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("range formatting must not be called when diff is empty");
+ })
+ .next();
+ let _no_format = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("full formatting must not be called when a diff is available but empty");
+ })
+ .next();
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ save.await;
+ cx.run_until_parked();
+ assert!(
+ !cx.read(|cx| editor.is_dirty(cx)),
+ "the buffer should be saved despite the skipped formatting"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_if_available_no_git_falls_back_to_full_format(cx: &mut TestAppContext) {
+ let (project, editor, cx, fake_server) = setup_range_format_test_with_capabilities(
+ cx,
+ lsp::ServerCapabilities {
+ document_range_formatting_provider: Some(lsp::OneOf::Left(true)),
+ document_formatting_provider: Some(lsp::OneOf::Left(true)),
+ ..lsp::ServerCapabilities::default()
+ },
+ )
+ .await;
+
+ update_test_language_settings(cx, &|settings| {
+ settings.defaults.format_on_save = Some(FormatOnSave::ModificationsIfAvailable);
+ });
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text("one\ntwo\nthree\n", window, cx)
+ });
+ assert!(cx.read(|cx| editor.is_dirty(cx)));
+
+ let _no_range_format = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("range formatting must not be called when no git diff is available");
+ })
+ .next();
+
+ let formatting_called = Arc::new(AtomicBool::new(false));
+ let formatting_called_clone = formatting_called.clone();
+ let mut formatting_rx =
+ fake_server.set_request_handler::(move |_, _| {
+ formatting_called_clone.store(true, atomic::Ordering::SeqCst);
+ async move { Ok(Some(Vec::new())) }
+ });
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ formatting_rx.next().await;
+ save.await;
+
+ assert!(
+ formatting_called.load(atomic::Ordering::SeqCst),
+ "ModificationsIfAvailable must fall back to full-buffer formatting when no git diff is available"
+ );
+}
+
+#[gpui::test]
+async fn test_modifications_if_available_lsp_no_range_support_falls_back_to_full_format(
+ cx: &mut TestAppContext,
+) {
+ init_test(cx, |_| {});
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/project"),
+ json!({
+ ".git": {},
+ "file.rs": "",
+ }),
+ )
+ .await;
+
+ let head_content = "line0\nline1\nline2\n";
+ 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", head_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(false)),
+ 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();
+ 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();
+
+ update_test_language_settings(cx, &|settings| {
+ settings.defaults.format_on_save = Some(FormatOnSave::ModificationsIfAvailable);
+ });
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.set_text("line0\nLINE1\nline2\n", window, cx);
+ });
+ cx.run_until_parked();
+ assert!(cx.read(|cx| editor.is_dirty(cx)));
+
+ let _no_range_format = fake_server
+ .set_request_handler::(move |_, _| async move {
+ panic!("rangeFormatting must not be called when LSP lacks range support");
+ })
+ .next();
+
+ let formatting_called = Arc::new(AtomicBool::new(false));
+ let formatting_called_clone = formatting_called.clone();
+ let mut formatting_rx =
+ fake_server.set_request_handler::(move |_, _| {
+ formatting_called_clone.store(true, atomic::Ordering::SeqCst);
+ async move { Ok(Some(Vec::new())) }
+ });
+
+ let save = editor
+ .update_in(cx, |editor, window, cx| {
+ editor.save(
+ SaveOptions {
+ format: true,
+ autosave: false,
+ force_format: false,
+ },
+ project.clone(),
+ window,
+ cx,
+ )
+ })
+ .unwrap();
+ formatting_rx.next().await;
+ save.await;
+
+ assert!(
+ formatting_called.load(atomic::Ordering::SeqCst),
+ "ModificationsIfAvailable must fall back to full-file formatting when the LSP lacks range support"
+ );
+}
+
#[gpui::test]
async fn test_range_format_not_called_for_clean_buffer(cx: &mut TestAppContext) {
let (project, editor, cx, fake_server) = setup_range_format_test(cx).await;
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index 4e97c8c3fe3..4acdb10ff75 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -19,12 +19,14 @@ use gpui::{
};
use language::{
Bias, Buffer, BufferRow, CharKind, CharScopeContext, HighlightedText, LocalFile, PLAIN_TEXT,
- Point, SelectionGoal, proto::serialize_anchor as serialize_text_anchor,
+ Point, SelectionGoal,
+ language_settings::{FormatOnSave, LanguageSettings},
+ proto::serialize_anchor as serialize_text_anchor,
};
use lsp::DiagnosticSeverity;
use multi_buffer::{BufferOffset, MultiBufferOffset, PathKey};
use project::{
- File, Project, ProjectItem as _, ProjectPath, lsp_store::FormatTrigger,
+ File, Project, ProjectItem as _, ProjectPath, git_store::GitStore, lsp_store::FormatTrigger,
project_settings::ProjectSettings, search::SearchQuery,
};
use rope::TextSummary;
@@ -39,7 +41,7 @@ use std::{
path::{Path, PathBuf},
sync::Arc,
};
-use text::{BufferId, BufferSnapshot, OffsetRangeExt, Selection};
+use text::{BufferId, BufferSnapshot, OffsetRangeExt, Selection, ToPoint as _};
use ui::{IconDecorationKind, prelude::*};
use util::{ResultExt, TryFutureExt, paths::PathExt, rel_path::RelPath};
use workspace::item::{Dedup, ItemSettings, SerializableItem, TabContentParams};
@@ -974,16 +976,21 @@ impl Item for Editor {
cx.spawn_in(window, async move |this, cx| {
if options.format {
- this.update_in(cx, |editor, window, cx| {
- editor.perform_format(
- project.clone(),
+ let format_task = this.update_in(cx, |editor, window, cx| {
+ let format_target = compute_format_target(
+ &buffers_to_save,
format_trigger,
- FormatTarget::Buffers(buffers_to_save.clone()),
- window,
+ editor.buffer(),
+ project.read(cx).git_store(),
cx,
- )
- })?
- .await?;
+ );
+ format_target.map(|target| {
+ editor.perform_format(project.clone(), format_trigger, target, window, cx)
+ })
+ })?;
+ if let Some(format_task) = format_task {
+ format_task.await?;
+ }
}
if !buffers_to_save.is_empty() {
@@ -2267,6 +2274,115 @@ fn chunk_search_range(
}))
}
+/// Decides what to format based on the `format_on_save` settings of the saved buffers.
+///
+/// In the modifications modes, only lines with unstaged changes are formatted.
+/// When no git diff is available for a buffer, `modifications` skips formatting while `modifications_if_available`
+/// falls back to formatting entire buffers.
+/// When a diff is available but empty, nothing is formatted in either mode.
+fn compute_format_target(
+ buffers: &HashSet>,
+ trigger: FormatTrigger,
+ multi_buffer: &Entity,
+ git_store: &Entity,
+ cx: &App,
+) -> Option {
+ if trigger == FormatTrigger::Manual {
+ return Some(FormatTarget::Buffers(buffers.clone()));
+ }
+
+ let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
+ let git_store = git_store.read(cx);
+
+ let mut fall_back_to_full_format = false;
+ let mut modified_ranges: Vec> = Vec::new();
+
+ for buffer_entity in buffers.iter() {
+ let buffer = buffer_entity.read(cx);
+ let settings = LanguageSettings::for_buffer(buffer, cx);
+ match settings.format_on_save {
+ FormatOnSave::On | FormatOnSave::Off => {
+ return Some(FormatTarget::Buffers(buffers.clone()));
+ }
+ FormatOnSave::Modifications | FormatOnSave::ModificationsIfAvailable => {}
+ }
+
+ let Some(diff_snapshot) = git_store
+ .get_unstaged_diff(buffer.remote_id(), cx)
+ .map(|diff| diff.read(cx).snapshot(cx))
+ else {
+ if settings.format_on_save == FormatOnSave::ModificationsIfAvailable {
+ fall_back_to_full_format = true;
+ }
+ continue;
+ };
+
+ let anchor_ranges = compute_modified_ranges(&buffer.snapshot(), &diff_snapshot);
+ let flat_anchors = anchor_ranges
+ .iter()
+ .flat_map(|range| [range.start, range.end])
+ .collect::>();
+ let multi_buffer_anchors =
+ multi_buffer_snapshot.text_anchors_to_visible_anchors(flat_anchors);
+ for pair in multi_buffer_anchors.chunks_exact(2) {
+ let (Some(start), Some(end)) = (&pair[0], &pair[1]) else {
+ continue;
+ };
+ modified_ranges
+ .push(start.to_point(&multi_buffer_snapshot)..end.to_point(&multi_buffer_snapshot));
+ }
+ }
+
+ if fall_back_to_full_format {
+ Some(FormatTarget::Buffers(buffers.clone()))
+ } else if modified_ranges.is_empty() {
+ None
+ } else {
+ Some(FormatTarget::Ranges(modified_ranges))
+ }
+}
+
+/// Computes the buffer ranges that have unstaged changes, expanded to full lines and
+/// with adjacent hunks merged, for use with format-on-save. An empty result means the
+/// buffer has no formatable modifications.
+fn compute_modified_ranges(
+ buffer_snapshot: &language::BufferSnapshot,
+ diff_snapshot: &buffer_diff::BufferDiffSnapshot,
+) -> Vec> {
+ let mut merged: Vec> = Vec::new();
+ for hunk in diff_snapshot.hunks(buffer_snapshot) {
+ let range = hunk.buffer_range;
+ if range.start.cmp(&range.end, buffer_snapshot).is_eq() {
+ // Deletion-only hunks produce no buffer content to format.
+ continue;
+ }
+ let start_point = range.start.to_point(buffer_snapshot);
+ let end_point = range.end.to_point(buffer_snapshot);
+ let start_row = start_point.row;
+ let end_row = if end_point.column == 0 && end_point.row > start_point.row {
+ end_point.row - 1
+ } else {
+ end_point.row
+ };
+ let line_start = text::Point::new(start_row, 0);
+ let line_end = text::Point::new(end_row, buffer_snapshot.line_len(end_row));
+ let expanded =
+ buffer_snapshot.anchor_before(line_start)..buffer_snapshot.anchor_after(line_end);
+
+ if let Some(last) = merged.last_mut() {
+ let last_end_point = last.end.to_point(buffer_snapshot);
+ if start_row <= last_end_point.row + 1 {
+ if expanded.end.to_point(buffer_snapshot) > last_end_point {
+ last.end = expanded.end;
+ }
+ continue;
+ }
+ }
+ merged.push(expanded);
+ }
+ merged
+}
+
#[cfg(test)]
mod tests {
use crate::editor_tests::init_test;
@@ -2921,4 +3037,124 @@ mod tests {
"Editor::deserialize should not add items to panes as a side effect"
);
}
+
+ #[gpui::test]
+ fn test_compute_modified_ranges_git_diff(cx: &mut gpui::TestAppContext) {
+ let base_text = "line0\nline1\nline2\nline3\nline4\nline5\nline6\n";
+ // Modify line1 and line5 to create two non-adjacent hunks.
+ let buffer_text = "line0\nMOD1\nline2\nline3\nline4\nMOD5\nline6\n";
+
+ let buffer = cx.new(|cx| language::Buffer::local(buffer_text, cx));
+ let diff_snapshot = buffer.update(cx, |buffer, cx| {
+ let diff = cx.new(|cx| {
+ buffer_diff::BufferDiff::new_with_base_text(base_text, &buffer.text_snapshot(), cx)
+ });
+ diff.read(cx).snapshot(cx)
+ });
+
+ let ranges = buffer.update(cx, |buffer, _cx| {
+ compute_modified_ranges(&buffer.snapshot(), &diff_snapshot)
+ });
+
+ assert_eq!(ranges.len(), 2, "expected 2 non-adjacent ranges");
+
+ buffer.update(cx, |buffer, _cx| {
+ let text_snapshot: &text::BufferSnapshot = buffer;
+ let r0 = ranges[0].start.to_point(text_snapshot)..ranges[0].end.to_point(text_snapshot);
+ let r1 = ranges[1].start.to_point(text_snapshot)..ranges[1].end.to_point(text_snapshot);
+ assert_eq!(r0.start.row, 1, "first hunk should start at row 1");
+ assert_eq!(r0.end.row, 1, "first hunk should end at row 1");
+ assert_eq!(r1.start.row, 5, "second hunk should start at row 5");
+ assert_eq!(r1.end.row, 5, "second hunk should end at row 5");
+ });
+ }
+
+ #[gpui::test]
+ fn test_compute_modified_ranges_unchanged_buffer(cx: &mut gpui::TestAppContext) {
+ let buffer_text = "line0\nline1\nline2\n";
+ let buffer = cx.new(|cx| language::Buffer::local(buffer_text, cx));
+ let diff_snapshot = buffer.update(cx, |buffer, cx| {
+ let diff = cx.new(|cx| {
+ buffer_diff::BufferDiff::new_with_base_text(
+ buffer_text,
+ &buffer.text_snapshot(),
+ cx,
+ )
+ });
+ diff.read(cx).snapshot(cx)
+ });
+
+ let ranges = buffer.update(cx, |buffer, _cx| {
+ compute_modified_ranges(&buffer.snapshot(), &diff_snapshot)
+ });
+
+ assert_eq!(
+ ranges,
+ Vec::new(),
+ "buffer that matches its diff base should produce no modified ranges"
+ );
+ }
+
+ #[gpui::test]
+ fn test_compute_modified_ranges_deletion_only(cx: &mut gpui::TestAppContext) {
+ let base_text = "line0\nline1\nline2\n";
+ // Buffer has line1 deleted (pure deletion).
+ let buffer_text = "line0\nline2\n";
+
+ let buffer = cx.new(|cx| language::Buffer::local(buffer_text, cx));
+ let diff_snapshot = buffer.update(cx, |buffer, cx| {
+ let diff = cx.new(|cx| {
+ buffer_diff::BufferDiff::new_with_base_text(base_text, &buffer.text_snapshot(), cx)
+ });
+ diff.read(cx).snapshot(cx)
+ });
+
+ // Verify the diff has a deletion hunk.
+ let hunk_count = buffer.update(cx, |buffer, _cx| {
+ let text_snapshot: &text::BufferSnapshot = buffer;
+ diff_snapshot.hunks(text_snapshot).count()
+ });
+ assert!(hunk_count > 0, "diff should have hunks");
+
+ let ranges = buffer.update(cx, |buffer, _cx| {
+ compute_modified_ranges(&buffer.snapshot(), &diff_snapshot)
+ });
+
+ assert_eq!(
+ ranges,
+ Vec::new(),
+ "deletion-only hunks should be skipped, leaving no ranges"
+ );
+ }
+
+ #[gpui::test]
+ fn test_compute_modified_ranges_adjacent_hunks(cx: &mut gpui::TestAppContext) {
+ let base_text = "line0\nline1\nline2\nline3\nline4\n";
+ // Modify lines 2 and 3 which are adjacent; they should merge into one range.
+ let buffer_text = "line0\nline1\nMOD2\nMOD3\nline4\n";
+
+ let buffer = cx.new(|cx| language::Buffer::local(buffer_text, cx));
+ let diff_snapshot = buffer.update(cx, |buffer, cx| {
+ let diff = cx.new(|cx| {
+ buffer_diff::BufferDiff::new_with_base_text(base_text, &buffer.text_snapshot(), cx)
+ });
+ diff.read(cx).snapshot(cx)
+ });
+
+ let ranges = buffer.update(cx, |buffer, _cx| {
+ compute_modified_ranges(&buffer.snapshot(), &diff_snapshot)
+ });
+
+ assert_eq!(
+ ranges.len(),
+ 1,
+ "adjacent hunks (rows 2 and 3) should be merged into one range"
+ );
+ buffer.update(cx, |buffer, _cx| {
+ let text_snapshot: &text::BufferSnapshot = buffer;
+ let r = ranges[0].start.to_point(text_snapshot)..ranges[0].end.to_point(text_snapshot);
+ assert_eq!(r.start.row, 2, "merged range should start at row 2");
+ assert_eq!(r.end.row, 3, "merged range should end at row 3");
+ });
+ }
}
diff --git a/crates/migrator/src/migrations/m_2025_10_02/settings.rs b/crates/migrator/src/migrations/m_2025_10_02/settings.rs
index 8942008e632..bb2a5bbb299 100644
--- a/crates/migrator/src/migrations/m_2025_10_02/settings.rs
+++ b/crates/migrator/src/migrations/m_2025_10_02/settings.rs
@@ -14,9 +14,9 @@ fn remove_formatters_on_save_inner(value: &mut Value, path: &[&str]) -> Result<(
let Some(format_on_save) = obj.get("format_on_save").cloned() else {
return Ok(());
};
- let is_format_on_save_set_to_formatter = format_on_save
- .as_str()
- .map_or(true, |s| s != "on" && s != "off");
+ let is_format_on_save_set_to_formatter = format_on_save.as_str().map_or(true, |s| {
+ s != "on" && s != "off" && s != "modifications" && s != "modifications_if_available"
+ });
if !is_format_on_save_set_to_formatter {
return Ok(());
}
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 1555a25dd21..f9e563ccdb3 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -1733,9 +1733,13 @@ impl LocalLspStore {
let formatters = match (trigger, &settings.format_on_save) {
(FormatTrigger::Save, FormatOnSave::Off) => &[],
- (FormatTrigger::Manual, _) | (FormatTrigger::Save, FormatOnSave::On) => {
- settings.formatter.as_ref()
- }
+ (FormatTrigger::Manual, _)
+ | (
+ FormatTrigger::Save,
+ FormatOnSave::On
+ | FormatOnSave::Modifications
+ | FormatOnSave::ModificationsIfAvailable,
+ ) => settings.formatter.as_ref(),
};
let formatters = code_actions_on_format_formatters
@@ -1763,6 +1767,7 @@ impl LocalLspStore {
&adapters_and_servers,
&settings,
request_timeout,
+ trigger,
logger,
cx,
)
@@ -1783,6 +1788,7 @@ impl LocalLspStore {
adapters_and_servers: &[(Arc, Arc)],
settings: &LanguageSettings,
request_timeout: Duration,
+ trigger: FormatTrigger,
logger: zlog::Logger,
cx: &mut AsyncApp,
) -> anyhow::Result<()> {
@@ -1925,23 +1931,22 @@ impl LocalLspStore {
};
let Some(language_server) = language_server else {
- log::debug!(
- "No language server found to format buffer '{:?}'. Skipping",
- buffer_path_abs.as_path().to_string_lossy()
+ zlog::debug!(
+ logger =>
+ "No language server found to format buffer {buffer_path_abs:?}. Skipping",
);
return Ok(());
};
zlog::trace!(
logger =>
- "Formatting buffer '{:?}' using language server '{:?}'",
- buffer_path_abs.as_path().to_string_lossy(),
+ "Formatting buffer {buffer_path_abs:?} using language server {:?}",
language_server.name()
);
let edits = if let Some(ranges) = buffer.ranges.as_ref() {
zlog::trace!(logger => "formatting ranges");
- Self::format_ranges_via_lsp(
+ let range_edits = Self::format_ranges_via_lsp(
&lsp_store,
&buffer.handle,
ranges,
@@ -1951,8 +1956,38 @@ impl LocalLspStore {
cx,
)
.await
- .context("Failed to format ranges via language server")?
- .unwrap_or_default()
+ .context("Failed to format ranges via language server")?;
+
+ match range_edits {
+ Some(edits) => edits,
+ None => {
+ if trigger == FormatTrigger::Save
+ && settings.format_on_save == FormatOnSave::ModificationsIfAvailable
+ {
+ zlog::debug!(
+ logger =>
+ "Falling back to full format - LSP does not support range formatting"
+ );
+ Self::format_via_lsp(
+ &lsp_store,
+ &buffer.handle,
+ buffer_path_abs,
+ &language_server,
+ &settings,
+ cx,
+ )
+ .await
+ .context("failed to format via language server")?
+ } else {
+ zlog::debug!(
+ logger =>
+ "Skipping range format - language server {:?} does not support range formatting",
+ language_server.name()
+ );
+ Vec::new()
+ }
+ }
+ }
} else {
zlog::trace!(logger => "formatting full");
Self::format_via_lsp(
diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs
index 29d9f91dc6b..ae63dbe75fc 100644
--- a/crates/settings/src/settings_store.rs
+++ b/crates/settings/src/settings_store.rs
@@ -2461,6 +2461,148 @@ mod tests {
.unindent(),
cx,
);
+
+ // formatOnSave: true with formatOnSaveMode: modificationsIfAvailable
+ check_vscode_import(
+ &mut store,
+ r#"{
+ }
+ "#
+ .unindent(),
+ r#"{ "editor.formatOnSave": true, "editor.formatOnSaveMode": "modificationsIfAvailable" }"#
+ .to_owned(),
+ r#"{
+ "base_keymap": "VSCode",
+ "minimap": {
+ "show": "always"
+ },
+ "format_on_save": "modifications_if_available"
+ }
+ "#
+ .unindent(),
+ cx,
+ );
+
+ // formatOnSave: true with formatOnSaveMode: modifications
+ check_vscode_import(
+ &mut store,
+ r#"{
+ }
+ "#
+ .unindent(),
+ r#"{ "editor.formatOnSave": true, "editor.formatOnSaveMode": "modifications" }"#
+ .to_owned(),
+ r#"{
+ "base_keymap": "VSCode",
+ "minimap": {
+ "show": "always"
+ },
+ "format_on_save": "modifications"
+ }
+ "#
+ .unindent(),
+ cx,
+ );
+
+ // formatOnSave: true with formatOnSaveMode: file
+ check_vscode_import(
+ &mut store,
+ r#"{
+ }
+ "#
+ .unindent(),
+ r#"{ "editor.formatOnSave": true, "editor.formatOnSaveMode": "file" }"#.to_owned(),
+ r#"{
+ "base_keymap": "VSCode",
+ "minimap": {
+ "show": "always"
+ },
+ "format_on_save": "on"
+ }
+ "#
+ .unindent(),
+ cx,
+ );
+
+ // formatOnSaveMode is ignored when formatOnSave is disabled, as in VS Code
+ check_vscode_import(
+ &mut store,
+ r#"{
+ }
+ "#
+ .unindent(),
+ r#"{ "editor.formatOnSave": false, "editor.formatOnSaveMode": "modifications" }"#
+ .to_owned(),
+ r#"{
+ "base_keymap": "VSCode",
+ "minimap": {
+ "show": "always"
+ },
+ "format_on_save": "off"
+ }
+ "#
+ .unindent(),
+ cx,
+ );
+
+ // formatOnSaveMode alone does nothing, as formatOnSave defaults to false in VS Code
+ check_vscode_import(
+ &mut store,
+ r#"{
+ }
+ "#
+ .unindent(),
+ r#"{ "editor.formatOnSaveMode": "modifications" }"#.to_owned(),
+ r#"{
+ "base_keymap": "VSCode",
+ "minimap": {
+ "show": "always"
+ }
+ }
+ "#
+ .unindent(),
+ cx,
+ );
+
+ // formatOnSaveMode not set, formatOnSave: true
+ check_vscode_import(
+ &mut store,
+ r#"{
+ }
+ "#
+ .unindent(),
+ r#"{ "editor.formatOnSave": true }"#.to_owned(),
+ r#"{
+ "base_keymap": "VSCode",
+ "minimap": {
+ "show": "always"
+ },
+ "format_on_save": "on"
+ }
+ "#
+ .unindent(),
+ cx,
+ );
+
+ // formatOnSaveMode not set, formatOnSave: false
+ check_vscode_import(
+ &mut store,
+ r#"{
+ }
+ "#
+ .unindent(),
+ r#"{ "editor.formatOnSave": false }"#.to_owned(),
+ r#"{
+ "base_keymap": "VSCode",
+ "minimap": {
+ "show": "always"
+ },
+ "format_on_save": "off"
+ }
+ "#
+ .unindent(),
+ cx,
+ );
}
#[track_caller]
diff --git a/crates/settings/src/vscode_import.rs b/crates/settings/src/vscode_import.rs
index 9b8584c4e6b..0d2f5511430 100644
--- a/crates/settings/src/vscode_import.rs
+++ b/crates/settings/src/vscode_import.rs
@@ -554,9 +554,15 @@ impl VsCodeSettings {
extend_comment_on_newline: None,
extend_list_on_newline: None,
indent_list_on_tab: None,
- format_on_save: self.read_bool("editor.guides.formatOnSave").map(|b| {
- if b {
- FormatOnSave::On
+ // In VS Code, `editor.formatOnSaveMode` only applies when `editor.formatOnSave` is enabled.
+ format_on_save: self.read_bool("editor.formatOnSave").map(|enabled| {
+ if enabled {
+ self.read_enum("editor.formatOnSaveMode", |s| match s {
+ "modificationsIfAvailable" => Some(FormatOnSave::ModificationsIfAvailable),
+ "modifications" => Some(FormatOnSave::Modifications),
+ _ => None,
+ })
+ .unwrap_or(FormatOnSave::On)
} else {
FormatOnSave::Off
}
diff --git a/crates/settings_content/src/language.rs b/crates/settings_content/src/language.rs
index f31ef08e1d2..71beec78f7d 100644
--- a/crates/settings_content/src/language.rs
+++ b/crates/settings_content/src/language.rs
@@ -923,12 +923,22 @@ pub struct PrettierSettingsContent {
strum::VariantArray,
strum::VariantNames,
)]
-#[serde(rename_all = "lowercase")]
+#[serde(rename_all = "snake_case")]
pub enum FormatOnSave {
/// Files should be formatted on save.
On,
/// Files should not be formatted on save.
Off,
+ /// Only lines with unstaged changes are formatted on save.
+ /// Requires source control and LSP range formatting support.
+ /// If no git diff is available or if the LSP doesn't support
+ /// range formatting, formatting is skipped.
+ Modifications,
+ /// Only lines with unstaged changes are formatted on save.
+ /// If no git diff is available (e.g., when source control is
+ /// unavailable) or if the LSP doesn't support range formatting,
+ /// falls back to formatting the whole file.
+ ModificationsIfAvailable,
}
/// Controls how line endings are normalized when a buffer is saved.
diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs
index ba35c4875ef..2f6ce0beec5 100644
--- a/crates/settings_ui/src/page_data.rs
+++ b/crates/settings_ui/src/page_data.rs
@@ -8934,7 +8934,7 @@ fn language_settings_data() -> Box<[SettingsPageItem]> {
SettingsPageItem::SectionHeader("Formatting"),
SettingsPageItem::SettingItem(SettingItem {
title: "Format On Save",
- description: "Whether or not to perform a buffer format before saving.",
+ description: "On: format the whole buffer.\nOff: do not format.\nModifications: format only lines with unstaged changes; skips formatting when a git diff or LSP range formatting is unavailable.\nModifications If Available: same, but falls back to formatting the whole buffer.",
field: Box::new(
// TODO(settings_ui): this setting should just be a bool
SettingField {
diff --git a/docs/src/reference/all-settings.md b/docs/src/reference/all-settings.md
index 1450b58d6fc..2ded300ce5d 100644
--- a/docs/src/reference/all-settings.md
+++ b/docs/src/reference/all-settings.md
@@ -1905,7 +1905,7 @@ While other options may be changed at a runtime and should be placed under `sett
}
```
-## Format On Save
+## Format On Save {#format-on-save}
- Description: Whether or not to perform a buffer format before saving.
- Setting: `format_on_save`
@@ -1929,6 +1929,26 @@ While other options may be changed at a runtime and should be placed under `sett
}
```
+3. `modifications`, formats only lines with unstaged changes:
+
+```json [settings]
+{
+ "format_on_save": "modifications"
+}
+```
+
+This mode requires source control and LSP range formatting support. If no git diff is available or if the LSP doesn't support range formatting, formatting is skipped. This is useful for editing legacy codebases where you want to avoid formatting changes in unrelated code.
+
+4. `modifications_if_available`, formats only modified lines with fallback to full file formatting:
+
+```json [settings]
+{
+ "format_on_save": "modifications_if_available"
+}
+```
+
+Similar to `modifications`, but behaves like `on` when range formatting cannot be applied: when no git diff is available (e.g., when source control is unavailable) or when the language server does not support range formatting. When a git diff is available but contains no unstaged changes, nothing is formatted.
+
## Formatter
- Description: How to perform a buffer format.
@@ -3279,7 +3299,7 @@ Examples:
- Description:
Preview tabs allow you to open files in preview mode, where they close automatically when you switch to another file unless you explicitly pin them. This is useful for quickly viewing files without cluttering your workspace. Preview tabs display their file names in italics. \
- There are several ways to convert a preview tab into a regular tab:
+ There are several ways to convert a preview tab into a regular tab:
- Double-clicking on the file
- Double-clicking on the tab header