Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #1418 from zed-industries/autoindent-on-paste

Browse source 
Auto-indent improvements
This commit is contained in:
Max Brunsfeld 2022-07-28 23:23:42 -07:00 • committed by GitHub
commit a842016380
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
21 changed files with 750 additions and 360 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock generated
View file

@ -2761,6 +2761,7 @@ dependencies = [
"rpc", "rpc",
"serde", "serde",
"serde_json", "serde_json",
"settings",
"similar", "similar",
"smallvec", "smallvec",
"smol", "smol",

1
crates/activity_indicator/src/activity_indicator.rs
View file

@ -82,6 +82,7 @@ impl ActivityIndicator {
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.edit( buffer.edit(
[(0..0, format!("Language server error: {}\n\n", lsp_name))], [(0..0, format!("Language server error: {}\n\n", lsp_name))],
None,
cx, cx,
); );
}); });

22
crates/collab/src/integration_tests.rs
View file

@ -842,8 +842,8 @@ async fn test_propagate_saves_and_fs_changes(
.update(cx_c, |p, cx| p.open_buffer((worktree_id, "file1"), cx)) .update(cx_c, |p, cx| p.open_buffer((worktree_id, "file1"), cx))
.await .await
.unwrap(); .unwrap();
buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "i-am-b, ")], cx)); buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "i-am-b, ")], None, cx));
buffer_c.update(cx_c, |buf, cx| buf.edit([(0..0, "i-am-c, ")], cx)); buffer_c.update(cx_c, |buf, cx| buf.edit([(0..0, "i-am-c, ")], None, cx));
// Open and edit that buffer as the host. // Open and edit that buffer as the host.
let buffer_a = project_a let buffer_a = project_a
@ -855,7 +855,7 @@ async fn test_propagate_saves_and_fs_changes(
.condition(cx_a, |buf, _| buf.text() == "i-am-c, i-am-b, ") .condition(cx_a, |buf, _| buf.text() == "i-am-c, i-am-b, ")
.await; .await;
buffer_a.update(cx_a, |buf, cx| { buffer_a.update(cx_a, |buf, cx| {
buf.edit([(buf.len()..buf.len(), "i-am-a")], cx) buf.edit([(buf.len()..buf.len(), "i-am-a")], None, cx)
}); });
// Wait for edits to propagate // Wait for edits to propagate
@ -871,7 +871,7 @@ async fn test_propagate_saves_and_fs_changes(
// Edit the buffer as the host and concurrently save as guest B. // Edit the buffer as the host and concurrently save as guest B.
let save_b = buffer_b.update(cx_b, |buf, cx| buf.save(cx)); let save_b = buffer_b.update(cx_b, |buf, cx| buf.save(cx));
buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "hi-a, ")], cx)); buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "hi-a, ")], None, cx));
save_b.await.unwrap(); save_b.await.unwrap();
assert_eq!( assert_eq!(
client_a.fs.load("/a/file1".as_ref()).await.unwrap(), client_a.fs.load("/a/file1".as_ref()).await.unwrap(),
@ -1237,7 +1237,7 @@ async fn test_buffer_conflict_after_save(cx_a: &mut TestAppContext, cx_b: &mut T
.await .await
.unwrap(); .unwrap();
buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "world ")], cx)); buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "world ")], None, cx));
buffer_b.read_with(cx_b, |buf, _| { buffer_b.read_with(cx_b, |buf, _| {
assert!(buf.is_dirty()); assert!(buf.is_dirty());
assert!(!buf.has_conflict()); assert!(!buf.has_conflict());
@ -1251,7 +1251,7 @@ async fn test_buffer_conflict_after_save(cx_a: &mut TestAppContext, cx_b: &mut T
assert!(!buf.has_conflict()); assert!(!buf.has_conflict());
}); });
buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "hello ")], cx)); buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "hello ")], None, cx));
buffer_b.read_with(cx_b, |buf, _| { buffer_b.read_with(cx_b, |buf, _| {
assert!(buf.is_dirty()); assert!(buf.is_dirty());
assert!(!buf.has_conflict()); assert!(!buf.has_conflict());
@ -1342,9 +1342,9 @@ async fn test_editing_while_guest_opens_buffer(
// Edit the buffer as client A while client B is still opening it. // Edit the buffer as client A while client B is still opening it.
cx_b.background().simulate_random_delay().await; cx_b.background().simulate_random_delay().await;
buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "X")], cx)); buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "X")], None, cx));
cx_b.background().simulate_random_delay().await; cx_b.background().simulate_random_delay().await;
buffer_a.update(cx_a, |buf, cx| buf.edit([(1..1, "Y")], cx)); buffer_a.update(cx_a, |buf, cx| buf.edit([(1..1, "Y")], None, cx));
let text = buffer_a.read_with(cx_a, |buf, _| buf.text()); let text = buffer_a.read_with(cx_a, |buf, _| buf.text());
let buffer_b = buffer_b.await.unwrap(); let buffer_b = buffer_b.await.unwrap();
@ -1882,8 +1882,8 @@ async fn test_reloading_buffer_manually(cx_a: &mut TestAppContext, cx_b: &mut Te
.await .await
.unwrap(); .unwrap();
buffer_b.update(cx_b, |buffer, cx| { buffer_b.update(cx_b, |buffer, cx| {
buffer.edit([(4..7, "six")], cx); buffer.edit([(4..7, "six")], None, cx);
buffer.edit([(10..11, "6")], cx); buffer.edit([(10..11, "6")], None, cx);
assert_eq!(buffer.text(), "let six = 6;"); assert_eq!(buffer.text(), "let six = 6;");
assert!(buffer.is_dirty()); assert!(buffer.is_dirty());
assert!(!buffer.has_conflict()); assert!(!buffer.has_conflict());
@ -2964,7 +2964,7 @@ async fn test_collaborating_with_renames(cx_a: &mut TestAppContext, cx_b: &mut T
); );
rename.editor.update(cx, |rename_editor, cx| { rename.editor.update(cx, |rename_editor, cx| {
rename_editor.buffer().update(cx, |rename_buffer, cx| { rename_editor.buffer().update(cx, |rename_buffer, cx| {
rename_buffer.edit([(0..3, "THREE")], cx); rename_buffer.edit([(0..3, "THREE")], None, cx);
}); });
}); });
}); });

3
crates/editor/src/display_map.rs
View file

@ -897,7 +897,7 @@ pub mod tests {
let ix = snapshot.buffer_snapshot.text().find("seven").unwrap(); let ix = snapshot.buffer_snapshot.text().find("seven").unwrap();
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.edit([(ix..ix, "and ")], cx); buffer.edit([(ix..ix, "and ")], None, cx);
}); });
let snapshot = map.update(cx, |map, cx| map.snapshot(cx)); let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
@ -936,6 +936,7 @@ pub mod tests {
(Point::new(1, 1)..Point::new(1, 1), "\t"), (Point::new(1, 1)..Point::new(1, 1), "\t"),
(Point::new(2, 1)..Point::new(2, 1), "\t"), (Point::new(2, 1)..Point::new(2, 1), "\t"),
], ],
None,
cx, cx,
) )
}); });

2
crates/editor/src/display_map/block_map.rs
View file

@ -1164,7 +1164,7 @@ mod tests {
// Insert a line break, separating two block decorations into separate lines. // Insert a line break, separating two block decorations into separate lines.
let buffer_snapshot = buffer.update(cx, |buffer, cx| { let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit([(Point::new(1, 1)..Point::new(1, 1), "!!!\n")], cx); buffer.edit([(Point::new(1, 1)..Point::new(1, 1), "!!!\n")], None, cx);
buffer.snapshot(cx) buffer.snapshot(cx)
}); });

7
crates/editor/src/display_map/fold_map.rs
View file

@ -1240,6 +1240,7 @@ mod tests {
(Point::new(0, 0)..Point::new(0, 1), "123"), (Point::new(0, 0)..Point::new(0, 1), "123"),
(Point::new(2, 3)..Point::new(2, 3), "123"), (Point::new(2, 3)..Point::new(2, 3), "123"),
], ],
None,
cx, cx,
); );
buffer.snapshot(cx) buffer.snapshot(cx)
@ -1262,7 +1263,7 @@ mod tests {
); );
let buffer_snapshot = buffer.update(cx, |buffer, cx| { let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit([(Point::new(2, 6)..Point::new(4, 3), "456")], cx); buffer.edit([(Point::new(2, 6)..Point::new(4, 3), "456")], None, cx);
buffer.snapshot(cx) buffer.snapshot(cx)
}); });
let (snapshot4, _) = map.read(buffer_snapshot.clone(), subscription.consume().into_inner()); let (snapshot4, _) = map.read(buffer_snapshot.clone(), subscription.consume().into_inner());
@ -1318,7 +1319,7 @@ mod tests {
// Edit within one of the folds. // Edit within one of the folds.
let buffer_snapshot = buffer.update(cx, |buffer, cx| { let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit([(0..1, "12345")], cx); buffer.edit([(0..1, "12345")], None, cx);
buffer.snapshot(cx) buffer.snapshot(cx)
}); });
let (snapshot, _) = let (snapshot, _) =
@ -1360,7 +1361,7 @@ mod tests {
assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee"); assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee");
let buffer_snapshot = buffer.update(cx, |buffer, cx| { let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit([(Point::new(2, 2)..Point::new(3, 1), "")], cx); buffer.edit([(Point::new(2, 2)..Point::new(3, 1), "")], None, cx);
buffer.snapshot(cx) buffer.snapshot(cx)
}); });
let (snapshot, _) = map.read(buffer_snapshot.clone(), subscription.consume().into_inner()); let (snapshot, _) = map.read(buffer_snapshot.clone(), subscription.consume().into_inner());

196
crates/editor/src/editor.rs
View file

@ -38,9 +38,9 @@ use hover_popover::{hide_hover, HoverState};
pub use items::MAX_TAB_TITLE_LEN; pub use items::MAX_TAB_TITLE_LEN;
pub use language::{char_kind, CharKind}; pub use language::{char_kind, CharKind};
use language::{ use language::{
BracketPair, Buffer, CodeAction, CodeLabel, Completion, Diagnostic, DiagnosticSeverity, AutoindentMode, BracketPair, Buffer, CodeAction, CodeLabel, Completion, Diagnostic,
IndentKind, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Point, Selection, SelectionGoal, DiagnosticSeverity, IndentKind, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Point,
TransactionId, Selection, SelectionGoal, TransactionId,
}; };
use link_go_to_definition::LinkGoToDefinitionState; use link_go_to_definition::LinkGoToDefinitionState;
pub use multi_buffer::{ pub use multi_buffer::{
@ -879,6 +879,7 @@ struct ActiveDiagnosticGroup {
pub struct ClipboardSelection { pub struct ClipboardSelection {
pub len: usize, pub len: usize,
pub is_entire_line: bool, pub is_entire_line: bool,
pub first_line_indent: u32,
} }
#[derive(Debug)] #[derive(Debug)]
@ -1464,7 +1465,8 @@ impl Editor {
S: ToOffset, S: ToOffset,
T: Into<Arc<str>>, T: Into<Arc<str>>,
{ {
self.buffer.update(cx, |buffer, cx| buffer.edit(edits, cx)); self.buffer
.update(cx, |buffer, cx| buffer.edit(edits, None, cx));
} }
pub fn edit_with_autoindent<I, S, T>(&mut self, edits: I, cx: &mut ViewContext<Self>) pub fn edit_with_autoindent<I, S, T>(&mut self, edits: I, cx: &mut ViewContext<Self>)
@ -1473,8 +1475,9 @@ impl Editor {
S: ToOffset, S: ToOffset,
T: Into<Arc<str>>, T: Into<Arc<str>>,
{ {
self.buffer self.buffer.update(cx, |buffer, cx| {
.update(cx, |buffer, cx| buffer.edit_with_autoindent(edits, cx)); buffer.edit(edits, Some(AutoindentMode::EachLine), cx)
});
} }
fn select(&mut self, Select(phase): &Select, cx: &mut ViewContext<Self>) { fn select(&mut self, Select(phase): &Select, cx: &mut ViewContext<Self>) {
@ -1887,9 +1890,7 @@ impl Editor {
.unzip() .unzip()
}; };
this.buffer.update(cx, |buffer, cx| { this.edit_with_autoindent(edits, cx);
buffer.edit_with_autoindent(edits, cx);
});
let buffer = this.buffer.read(cx).snapshot(cx); let buffer = this.buffer.read(cx).snapshot(cx);
let new_selections = selection_fixup_info let new_selections = selection_fixup_info
.into_iter() .into_iter()
@ -1922,10 +1923,11 @@ impl Editor {
}) })
.collect::<Vec<_>>() .collect::<Vec<_>>()
}; };
buffer.edit_with_autoindent( buffer.edit(
old_selections old_selections
.iter() .iter()
.map(|s| (s.start..s.end, text.clone())), .map(|s| (s.start..s.end, text.clone())),
Some(AutoindentMode::EachLine),
cx, cx,
); );
anchors anchors
@ -1986,6 +1988,7 @@ impl Editor {
(s.end.clone()..s.end.clone(), pair_end.clone()), (s.end.clone()..s.end.clone(), pair_end.clone()),
] ]
}), }),
None,
cx, cx,
); );
}); });
@ -2061,6 +2064,7 @@ impl Editor {
selection_ranges selection_ranges
.iter() .iter()
.map(|range| (range.clone(), pair_end.clone())), .map(|range| (range.clone(), pair_end.clone())),
None,
cx, cx,
); );
snapshot = buffer.snapshot(cx); snapshot = buffer.snapshot(cx);
@ -2363,8 +2367,11 @@ impl Editor {
this.insert_snippet(&ranges, snippet, cx).log_err(); this.insert_snippet(&ranges, snippet, cx).log_err();
} else { } else {
this.buffer.update(cx, |buffer, cx| { this.buffer.update(cx, |buffer, cx| {
buffer buffer.edit(
.edit_with_autoindent(ranges.iter().map(|range| (range.clone(), text)), cx); ranges.iter().map(|range| (range.clone(), text)),
Some(AutoindentMode::EachLine),
cx,
);
}); });
} }
}); });
@ -2725,11 +2732,12 @@ impl Editor {
) -> Result<()> { ) -> Result<()> {
let tabstops = self.buffer.update(cx, |buffer, cx| { let tabstops = self.buffer.update(cx, |buffer, cx| {
let snippet_text: Arc<str> = snippet.text.clone().into(); let snippet_text: Arc<str> = snippet.text.clone().into();
buffer.edit_with_autoindent( buffer.edit(
insertion_ranges insertion_ranges
.iter() .iter()
.cloned() .cloned()
.map(|range| (range, snippet_text.clone())), .map(|range| (range, snippet_text.clone())),
Some(AutoindentMode::EachLine),
cx, cx,
); );
@ -2933,7 +2941,11 @@ impl Editor {
let chars_to_next_tab_stop = tab_size - (char_column as u32 % tab_size); let chars_to_next_tab_stop = tab_size - (char_column as u32 % tab_size);
IndentSize::spaces(chars_to_next_tab_stop) IndentSize::spaces(chars_to_next_tab_stop)
}; };
buffer.edit([(cursor..cursor, tab_size.chars().collect::<String>())], cx); buffer.edit(
[(cursor..cursor, tab_size.chars().collect::<String>())],
None,
cx,
);
cursor.column += tab_size.len; cursor.column += tab_size.len;
selection.start = cursor; selection.start = cursor;
selection.end = cursor; selection.end = cursor;
@ -3006,6 +3018,7 @@ impl Editor {
row_start..row_start, row_start..row_start,
indent_delta.chars().collect::<String>(), indent_delta.chars().collect::<String>(),
)], )],
None,
cx, cx,
); );
@ -3080,6 +3093,7 @@ impl Editor {
deletion_ranges deletion_ranges
.into_iter() .into_iter()
.map(|range| (range, empty_str.clone())), .map(|range| (range, empty_str.clone())),
None,
cx, cx,
); );
}); });
@ -3145,6 +3159,7 @@ impl Editor {
edit_ranges edit_ranges
.into_iter() .into_iter()
.map(|range| (range, empty_str.clone())), .map(|range| (range, empty_str.clone())),
None,
cx, cx,
); );
buffer.snapshot(cx) buffer.snapshot(cx)
@ -3202,7 +3217,7 @@ impl Editor {
self.transact(cx, |this, cx| { self.transact(cx, |this, cx| {
this.buffer.update(cx, |buffer, cx| { this.buffer.update(cx, |buffer, cx| {
buffer.edit(edits, cx); buffer.edit(edits, None, cx);
}); });
this.request_autoscroll(Autoscroll::Fit, cx); this.request_autoscroll(Autoscroll::Fit, cx);
@ -3311,7 +3326,7 @@ impl Editor {
this.unfold_ranges(unfold_ranges, true, cx); this.unfold_ranges(unfold_ranges, true, cx);
this.buffer.update(cx, |buffer, cx| { this.buffer.update(cx, |buffer, cx| {
for (range, text) in edits { for (range, text) in edits {
buffer.edit([(range, text)], cx); buffer.edit([(range, text)], None, cx);
} }
}); });
this.fold_ranges(refold_ranges, cx); this.fold_ranges(refold_ranges, cx);
@ -3416,7 +3431,7 @@ impl Editor {
this.unfold_ranges(unfold_ranges, true, cx); this.unfold_ranges(unfold_ranges, true, cx);
this.buffer.update(cx, |buffer, cx| { this.buffer.update(cx, |buffer, cx| {
for (range, text) in edits { for (range, text) in edits {
buffer.edit([(range, text)], cx); buffer.edit([(range, text)], None, cx);
} }
}); });
this.fold_ranges(refold_ranges, cx); this.fold_ranges(refold_ranges, cx);
@ -3467,7 +3482,8 @@ impl Editor {
}); });
edits edits
}); });
this.buffer.update(cx, |buffer, cx| buffer.edit(edits, cx)); this.buffer
.update(cx, |buffer, cx| buffer.edit(edits, None, cx));
let selections = this.selections.all::<usize>(cx); let selections = this.selections.all::<usize>(cx);
this.change_selections(Some(Autoscroll::Fit), cx, |s| { this.change_selections(Some(Autoscroll::Fit), cx, |s| {
s.select(selections); s.select(selections);
@ -3497,6 +3513,7 @@ impl Editor {
clipboard_selections.push(ClipboardSelection { clipboard_selections.push(ClipboardSelection {
len, len,
is_entire_line, is_entire_line,
first_line_indent: buffer.indent_size_for_line(selection.start.row).len,
}); });
} }
} }
@ -3534,6 +3551,7 @@ impl Editor {
clipboard_selections.push(ClipboardSelection { clipboard_selections.push(ClipboardSelection {
len, len,
is_entire_line, is_entire_line,
first_line_indent: buffer.indent_size_for_line(start.row).len,
}); });
} }
} }
@ -3568,18 +3586,22 @@ impl Editor {
let snapshot = buffer.read(cx); let snapshot = buffer.read(cx);
let mut start_offset = 0; let mut start_offset = 0;
let mut edits = Vec::new(); let mut edits = Vec::new();
let mut start_columns = Vec::new();
let line_mode = this.selections.line_mode; let line_mode = this.selections.line_mode;
for (ix, selection) in old_selections.iter().enumerate() { for (ix, selection) in old_selections.iter().enumerate() {
let to_insert; let to_insert;
let entire_line; let entire_line;
let start_column;
if let Some(clipboard_selection) = clipboard_selections.get(ix) { if let Some(clipboard_selection) = clipboard_selections.get(ix) {
let end_offset = start_offset + clipboard_selection.len; let end_offset = start_offset + clipboard_selection.len;
to_insert = &clipboard_text[start_offset..end_offset]; to_insert = &clipboard_text[start_offset..end_offset];
entire_line = clipboard_selection.is_entire_line; entire_line = clipboard_selection.is_entire_line;
start_offset = end_offset; start_offset = end_offset;
start_column = clipboard_selection.first_line_indent;
} else { } else {
to_insert = clipboard_text.as_str(); to_insert = clipboard_text.as_str();
entire_line = all_selections_were_entire_line; entire_line = all_selections_were_entire_line;
start_column = 0;
} }
// If the corresponding selection was empty when this slice of the // If the corresponding selection was empty when this slice of the
@ -3595,9 +3617,16 @@ impl Editor {
}; };
edits.push((range, to_insert)); edits.push((range, to_insert));
start_columns.push(start_column);
} }
drop(snapshot); drop(snapshot);
buffer.edit_with_autoindent(edits, cx); buffer.edit(
edits,
Some(AutoindentMode::Block {
original_indent_columns: start_columns,
}),
cx,
);
}); });
let selections = this.selections.all::<usize>(cx); let selections = this.selections.all::<usize>(cx);
@ -4432,6 +4461,7 @@ impl Editor {
.iter() .iter()
.cloned() .cloned()
.map(|range| (range, empty_str.clone())), .map(|range| (range, empty_str.clone())),
None,
cx, cx,
); );
} else { } else {
@ -4441,7 +4471,7 @@ impl Editor {
let position = Point::new(range.start.row, min_column); let position = Point::new(range.start.row, min_column);
(position..position, full_comment_prefix.clone()) (position..position, full_comment_prefix.clone())
}); });
buffer.edit(edits, cx); buffer.edit(edits, None, cx);
} }
} }
} }
@ -4875,9 +4905,9 @@ impl Editor {
editor.override_text_style = editor.override_text_style =
Some(Box::new(move |style| old_highlight_id.style(&style.syntax))); Some(Box::new(move |style| old_highlight_id.style(&style.syntax)));
} }
editor editor.buffer.update(cx, |buffer, cx| {
.buffer buffer.edit([(0..0, old_name.clone())], None, cx)
.update(cx, |buffer, cx| buffer.edit([(0..0, old_name.clone())], cx)); });
editor.select_all(&SelectAll, cx); editor.select_all(&SelectAll, cx);
editor editor
}); });
@ -6658,8 +6688,8 @@ mod tests {
// Simulate an edit in another editor // Simulate an edit in another editor
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.start_transaction_at(now, cx); buffer.start_transaction_at(now, cx);
buffer.edit([(0..1, "a")], cx); buffer.edit([(0..1, "a")], None, cx);
buffer.edit([(1..1, "b")], cx); buffer.edit([(1..1, "b")], None, cx);
buffer.end_transaction_at(now, cx); buffer.end_transaction_at(now, cx);
}); });
@ -7200,6 +7230,7 @@ mod tests {
(Point::new(1, 0)..Point::new(1, 0), "\t"), (Point::new(1, 0)..Point::new(1, 0), "\t"),
(Point::new(1, 1)..Point::new(1, 1), "\t"), (Point::new(1, 1)..Point::new(1, 1), "\t"),
], ],
None,
cx, cx,
); );
}); });
@ -7836,6 +7867,7 @@ mod tests {
(Point::new(1, 2)..Point::new(3, 0), ""), (Point::new(1, 2)..Point::new(3, 0), ""),
(Point::new(4, 2)..Point::new(6, 0), ""), (Point::new(4, 2)..Point::new(6, 0), ""),
], ],
None,
cx, cx,
); );
assert_eq!( assert_eq!(
@ -7894,7 +7926,7 @@ mod tests {
// Edit the buffer directly, deleting ranges surrounding the editor's selections // Edit the buffer directly, deleting ranges surrounding the editor's selections
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.edit([(2..5, ""), (10..13, ""), (18..21, "")], cx); buffer.edit([(2..5, ""), (10..13, ""), (18..21, "")], None, cx);
assert_eq!(buffer.read(cx).text(), "a(), b(), c()".unindent()); assert_eq!(buffer.read(cx).text(), "a(), b(), c()".unindent());
}); });
@ -8631,6 +8663,118 @@ mod tests {
t|he lazy dog"}); t|he lazy dog"});
} }
#[gpui::test]
async fn test_paste_multiline(cx: &mut gpui::TestAppContext) {
let mut cx = EditorTestContext::new(cx).await;
let language = Arc::new(Language::new(
LanguageConfig::default(),
Some(tree_sitter_rust::language()),
));
cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
// Cut an indented block, without the leading whitespace.
cx.set_state(indoc! {"
const a = (
b(),
[c(
d,
e
)}
);
"});
cx.update_editor(|e, cx| e.cut(&Cut, cx));
cx.assert_editor_state(indoc! {"
const a = (
b(),
|
);
"});
// Paste it at the same position.
cx.update_editor(|e, cx| e.paste(&Paste, cx));
cx.assert_editor_state(indoc! {"
const a = (
b(),
c(
d,
e
)|
);
"});
// Paste it at a line with a lower indent level.
cx.update_editor(|e, cx| e.paste(&Paste, cx));
cx.set_state(indoc! {"
|
const a = (
b(),
);
"});
cx.update_editor(|e, cx| e.paste(&Paste, cx));
cx.assert_editor_state(indoc! {"
c(
d,
e
)|
const a = (
b(),
);
"});
// Cut an indented block, with the leading whitespace.
cx.set_state(indoc! {"
const a = (
b(),
[ c(
d,
e
)
});
"});
cx.update_editor(|e, cx| e.cut(&Cut, cx));
cx.assert_editor_state(indoc! {"
const a = (
b(),
|);
"});
// Paste it at the same position.
cx.update_editor(|e, cx| e.paste(&Paste, cx));
cx.assert_editor_state(indoc! {"
const a = (
b(),
c(
d,
e
)
|);
"});
// Paste it at a line with a higher indent level.
cx.set_state(indoc! {"
const a = (
b(),
c(
d,
e|
)
);
"});
cx.update_editor(|e, cx| e.paste(&Paste, cx));
cx.set_state(indoc! {"
const a = (
b(),
c(
d,
ec(
d,
e
)|
)
);
"});
}
#[gpui::test] #[gpui::test]
fn test_select_all(cx: &mut gpui::MutableAppContext) { fn test_select_all(cx: &mut gpui::MutableAppContext) {
cx.set_global(Settings::test(cx)); cx.set_global(Settings::test(cx));

153
crates/editor/src/multi_buffer.rs
View file

@ -7,11 +7,10 @@ use collections::{Bound, HashMap, HashSet};
use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task}; use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
pub use language::Completion; pub use language::Completion;
use language::{ use language::{
char_kind, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, DiagnosticEntry, Event, File, char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk,
IndentSize, Language, OffsetRangeExt, Outline, OutlineItem, Selection, ToOffset as _, DiagnosticEntry, Event, File, IndentSize, Language, OffsetRangeExt, Outline, OutlineItem,
ToOffsetUtf16 as _, ToPoint as _, ToPointUtf16 as _, TransactionId, Selection, ToOffset as _, ToOffsetUtf16 as _, ToPoint as _, ToPointUtf16 as _, TransactionId,
}; };
use settings::Settings;
use smallvec::SmallVec; use smallvec::SmallVec;
use std::{ use std::{
borrow::Cow, borrow::Cow,
@ -303,28 +302,10 @@ impl MultiBuffer {
self.read(cx).symbols_containing(offset, theme) self.read(cx).symbols_containing(offset, theme)
} }
pub fn edit<I, S, T>(&mut self, edits: I, cx: &mut ModelContext<Self>) pub fn edit<I, S, T>(
where
I: IntoIterator<Item = (Range<S>, T)>,
S: ToOffset,
T: Into<Arc<str>>,
{
self.edit_internal(edits, false, cx)
}
pub fn edit_with_autoindent<I, S, T>(&mut self, edits: I, cx: &mut ModelContext<Self>)
where
I: IntoIterator<Item = (Range<S>, T)>,
S: ToOffset,
T: Into<Arc<str>>,
{
self.edit_internal(edits, true, cx)
}
pub fn edit_internal<I, S, T>(
&mut self, &mut self,
edits: I, edits: I,
autoindent: bool, mut autoindent_mode: Option<AutoindentMode>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) where ) where
I: IntoIterator<Item = (Range<S>, T)>, I: IntoIterator<Item = (Range<S>, T)>,
@ -346,26 +327,23 @@ impl MultiBuffer {
if let Some(buffer) = self.as_singleton() { if let Some(buffer) = self.as_singleton() {
return buffer.update(cx, |buffer, cx| { return buffer.update(cx, |buffer, cx| {
if autoindent { buffer.edit(edits, autoindent_mode, cx);
let language_name = buffer.language().map(|language| language.name());
let settings = cx.global::<Settings>();
let indent_size = if settings.hard_tabs(language_name.as_deref()) {
IndentSize::tab()
} else {
IndentSize::spaces(settings.tab_size(language_name.as_deref()).get())
};
buffer.edit_with_autoindent(edits, indent_size, cx);
} else {
buffer.edit(edits, cx);
}
}); });
} }
let mut buffer_edits: HashMap<usize, Vec<(Range<usize>, Arc<str>, bool)>> = let original_indent_columns = match &mut autoindent_mode {
Some(AutoindentMode::Block {
original_indent_columns,
}) => mem::take(original_indent_columns),
_ => Default::default(),
};
let mut buffer_edits: HashMap<usize, Vec<(Range<usize>, Arc<str>, bool, u32)>> =
Default::default(); Default::default();
let mut cursor = snapshot.excerpts.cursor::<usize>(); let mut cursor = snapshot.excerpts.cursor::<usize>();
for (range, new_text) in edits { for (ix, (range, new_text)) in edits.enumerate() {
let new_text: Arc<str> = new_text.into(); let new_text: Arc<str> = new_text.into();
let original_indent_column = original_indent_columns.get(ix).copied().unwrap_or(0);
cursor.seek(&range.start, Bias::Right, &()); cursor.seek(&range.start, Bias::Right, &());
if cursor.item().is_none() && range.start == *cursor.start() { if cursor.item().is_none() && range.start == *cursor.start() {
cursor.prev(&()); cursor.prev(&());
@ -396,7 +374,12 @@ impl MultiBuffer {
buffer_edits buffer_edits
.entry(start_excerpt.buffer_id) .entry(start_excerpt.buffer_id)
.or_insert(Vec::new()) .or_insert(Vec::new())
.push((buffer_start..buffer_end, new_text, true)); .push((
buffer_start..buffer_end,
new_text,
true,
original_indent_column,
));
} else { } else {
let start_excerpt_range = buffer_start let start_excerpt_range = buffer_start
..start_excerpt ..start_excerpt
@ -413,11 +396,21 @@ impl MultiBuffer {
buffer_edits buffer_edits
.entry(start_excerpt.buffer_id) .entry(start_excerpt.buffer_id)
.or_insert(Vec::new()) .or_insert(Vec::new())
.push((start_excerpt_range, new_text.clone(), true)); .push((
start_excerpt_range,
new_text.clone(),
true,
original_indent_column,
));
buffer_edits buffer_edits
.entry(end_excerpt.buffer_id) .entry(end_excerpt.buffer_id)
.or_insert(Vec::new()) .or_insert(Vec::new())
.push((end_excerpt_range, new_text.clone(), false)); .push((
end_excerpt_range,
new_text.clone(),
false,
original_indent_column,
));
cursor.seek(&range.start, Bias::Right, &()); cursor.seek(&range.start, Bias::Right, &());
cursor.next(&()); cursor.next(&());
@ -432,6 +425,7 @@ impl MultiBuffer {
excerpt.range.context.to_offset(&excerpt.buffer), excerpt.range.context.to_offset(&excerpt.buffer),
new_text.clone(), new_text.clone(),
false, false,
original_indent_column,
)); ));
cursor.next(&()); cursor.next(&());
} }
@ -439,19 +433,25 @@ impl MultiBuffer {
} }
for (buffer_id, mut edits) in buffer_edits { for (buffer_id, mut edits) in buffer_edits {
edits.sort_unstable_by_key(|(range, _, _)| range.start); edits.sort_unstable_by_key(|(range, _, _, _)| range.start);
self.buffers.borrow()[&buffer_id] self.buffers.borrow()[&buffer_id]
.buffer .buffer
.update(cx, |buffer, cx| { .update(cx, |buffer, cx| {
let mut edits = edits.into_iter().peekable(); let mut edits = edits.into_iter().peekable();
let mut insertions = Vec::new(); let mut insertions = Vec::new();
let mut original_indent_columns = Vec::new();
let mut deletions = Vec::new(); let mut deletions = Vec::new();
let empty_str: Arc<str> = "".into(); let empty_str: Arc<str> = "".into();
while let Some((mut range, new_text, mut is_insertion)) = edits.next() { while let Some((
while let Some((next_range, _, next_is_insertion)) = edits.peek() { mut range,
new_text,
mut is_insertion,
original_indent_column,
)) = edits.next()
{
while let Some((next_range, _, next_is_insertion, _)) = edits.peek() {
if range.end >= next_range.start { if range.end >= next_range.start {
range.end = cmp::max(next_range.end, range.end); range.end = cmp::max(next_range.end, range.end);
is_insertion |= *next_is_insertion; is_insertion |= *next_is_insertion;
edits.next(); edits.next();
} else { } else {
@ -460,6 +460,7 @@ impl MultiBuffer {
} }
if is_insertion { if is_insertion {
original_indent_columns.push(original_indent_column);
insertions.push(( insertions.push((
buffer.anchor_before(range.start)..buffer.anchor_before(range.end), buffer.anchor_before(range.start)..buffer.anchor_before(range.end),
new_text.clone(), new_text.clone(),
@ -471,22 +472,26 @@ impl MultiBuffer {
)); ));
} }
} }
let language_name = buffer.language().map(|l| l.name());
if autoindent { let deletion_autoindent_mode =
let settings = cx.global::<Settings>(); if let Some(AutoindentMode::Block { .. }) = autoindent_mode {
let indent_size = if settings.hard_tabs(language_name.as_deref()) { Some(AutoindentMode::Block {
IndentSize::tab() original_indent_columns: Default::default(),
})
} else { } else {
IndentSize::spaces(settings.tab_size(language_name.as_deref()).get()) None
};
let insertion_autoindent_mode =
if let Some(AutoindentMode::Block { .. }) = autoindent_mode {
Some(AutoindentMode::Block {
original_indent_columns,
})
} else {
None
}; };
buffer.edit_with_autoindent(deletions, indent_size, cx); buffer.edit(deletions, deletion_autoindent_mode, cx);
buffer.edit_with_autoindent(insertions, indent_size, cx); buffer.edit(insertions, insertion_autoindent_mode, cx);
} else {
buffer.edit(deletions, cx);
buffer.edit(insertions, cx);
}
}) })
} }
} }
@ -1402,7 +1407,7 @@ impl MultiBuffer {
log::info!("mutating multi-buffer with {:?}", edits); log::info!("mutating multi-buffer with {:?}", edits);
drop(snapshot); drop(snapshot);
self.edit(edits, cx); self.edit(edits, None, cx);
} }
pub fn randomly_edit_excerpts( pub fn randomly_edit_excerpts(
@ -3220,6 +3225,7 @@ mod tests {
use gpui::MutableAppContext; use gpui::MutableAppContext;
use language::{Buffer, Rope}; use language::{Buffer, Rope};
use rand::prelude::*; use rand::prelude::*;
use settings::Settings;
use std::{env, rc::Rc}; use std::{env, rc::Rc};
use text::{Point, RandomCharIter}; use text::{Point, RandomCharIter};
use util::test::sample_text; use util::test::sample_text;
@ -3239,7 +3245,7 @@ mod tests {
.collect::<Vec<_>>() .collect::<Vec<_>>()
); );
buffer.update(cx, |buffer, cx| buffer.edit([(1..3, "XXX\n")], cx)); buffer.update(cx, |buffer, cx| buffer.edit([(1..3, "XXX\n")], None, cx));
let snapshot = multibuffer.read(cx).snapshot(cx); let snapshot = multibuffer.read(cx).snapshot(cx);
assert_eq!(snapshot.text(), buffer.read(cx).text()); assert_eq!(snapshot.text(), buffer.read(cx).text());
@ -3262,11 +3268,11 @@ mod tests {
let snapshot = multibuffer.read(cx).snapshot(cx); let snapshot = multibuffer.read(cx).snapshot(cx);
assert_eq!(snapshot.text(), "a"); assert_eq!(snapshot.text(), "a");
guest_buffer.update(cx, |buffer, cx| buffer.edit([(1..1, "b")], cx)); guest_buffer.update(cx, |buffer, cx| buffer.edit([(1..1, "b")], None, cx));
let snapshot = multibuffer.read(cx).snapshot(cx); let snapshot = multibuffer.read(cx).snapshot(cx);
assert_eq!(snapshot.text(), "ab"); assert_eq!(snapshot.text(), "ab");
guest_buffer.update(cx, |buffer, cx| buffer.edit([(2..2, "c")], cx)); guest_buffer.update(cx, |buffer, cx| buffer.edit([(2..2, "c")], None, cx));
let snapshot = multibuffer.read(cx).snapshot(cx); let snapshot = multibuffer.read(cx).snapshot(cx);
assert_eq!(snapshot.text(), "abc"); assert_eq!(snapshot.text(), "abc");
} }
@ -3407,6 +3413,7 @@ mod tests {
(Point::new(0, 0)..Point::new(0, 0), text), (Point::new(0, 0)..Point::new(0, 0), text),
(Point::new(2, 1)..Point::new(2, 3), text), (Point::new(2, 1)..Point::new(2, 3), text),
], ],
None,
cx, cx,
); );
}); });
@ -3544,8 +3551,8 @@ mod tests {
let multibuffer = cx.add_model(|cx| MultiBuffer::singleton(buffer.clone(), cx)); let multibuffer = cx.add_model(|cx| MultiBuffer::singleton(buffer.clone(), cx));
let old_snapshot = multibuffer.read(cx).snapshot(cx); let old_snapshot = multibuffer.read(cx).snapshot(cx);
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.edit([(0..0, "X")], cx); buffer.edit([(0..0, "X")], None, cx);
buffer.edit([(5..5, "Y")], cx); buffer.edit([(5..5, "Y")], None, cx);
}); });
let new_snapshot = multibuffer.read(cx).snapshot(cx); let new_snapshot = multibuffer.read(cx).snapshot(cx);
@ -3592,12 +3599,12 @@ mod tests {
assert_eq!(Anchor::max().to_offset(&old_snapshot), 10); assert_eq!(Anchor::max().to_offset(&old_snapshot), 10);
buffer_1.update(cx, |buffer, cx| { buffer_1.update(cx, |buffer, cx| {
buffer.edit([(0..0, "W")], cx); buffer.edit([(0..0, "W")], None, cx);
buffer.edit([(5..5, "X")], cx); buffer.edit([(5..5, "X")], None, cx);
}); });
buffer_2.update(cx, |buffer, cx| { buffer_2.update(cx, |buffer, cx| {
buffer.edit([(0..0, "Y")], cx); buffer.edit([(0..0, "Y")], None, cx);
buffer.edit([(6..6, "Z")], cx); buffer.edit([(6..6, "Z")], None, cx);
}); });
let new_snapshot = multibuffer.read(cx).snapshot(cx); let new_snapshot = multibuffer.read(cx).snapshot(cx);
@ -3626,7 +3633,7 @@ mod tests {
// Create an insertion id in buffer 1 that doesn't exist in buffer 2. // Create an insertion id in buffer 1 that doesn't exist in buffer 2.
// Add an excerpt from buffer 1 that spans this new insertion. // Add an excerpt from buffer 1 that spans this new insertion.
buffer_1.update(cx, |buffer, cx| buffer.edit([(4..4, "123")], cx)); buffer_1.update(cx, |buffer, cx| buffer.edit([(4..4, "123")], None, cx));
let excerpt_id_1 = multibuffer.update(cx, |multibuffer, cx| { let excerpt_id_1 = multibuffer.update(cx, |multibuffer, cx| {
multibuffer multibuffer
.push_excerpts( .push_excerpts(
@ -4199,6 +4206,7 @@ mod tests {
(Point::new(0, 0)..Point::new(0, 0), "A"), (Point::new(0, 0)..Point::new(0, 0), "A"),
(Point::new(1, 0)..Point::new(1, 0), "A"), (Point::new(1, 0)..Point::new(1, 0), "A"),
], ],
None,
cx, cx,
); );
multibuffer.edit( multibuffer.edit(
@ -4206,6 +4214,7 @@ mod tests {
(Point::new(0, 1)..Point::new(0, 1), "B"), (Point::new(0, 1)..Point::new(0, 1), "B"),
(Point::new(1, 1)..Point::new(1, 1), "B"), (Point::new(1, 1)..Point::new(1, 1), "B"),
], ],
None,
cx, cx,
); );
multibuffer.end_transaction_at(now, cx); multibuffer.end_transaction_at(now, cx);
@ -4214,19 +4223,19 @@ mod tests {
// Edit buffer 1 through the multibuffer // Edit buffer 1 through the multibuffer
now += 2 * group_interval; now += 2 * group_interval;
multibuffer.start_transaction_at(now, cx); multibuffer.start_transaction_at(now, cx);
multibuffer.edit([(2..2, "C")], cx); multibuffer.edit([(2..2, "C")], None, cx);
multibuffer.end_transaction_at(now, cx); multibuffer.end_transaction_at(now, cx);
assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678"); assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");
// Edit buffer 1 independently // Edit buffer 1 independently
buffer_1.update(cx, |buffer_1, cx| { buffer_1.update(cx, |buffer_1, cx| {
buffer_1.start_transaction_at(now); buffer_1.start_transaction_at(now);
buffer_1.edit([(3..3, "D")], cx); buffer_1.edit([(3..3, "D")], None, cx);
buffer_1.end_transaction_at(now, cx); buffer_1.end_transaction_at(now, cx);
now += 2 * group_interval; now += 2 * group_interval;
buffer_1.start_transaction_at(now); buffer_1.start_transaction_at(now);
buffer_1.edit([(4..4, "E")], cx); buffer_1.edit([(4..4, "E")], None, cx);
buffer_1.end_transaction_at(now, cx); buffer_1.end_transaction_at(now, cx);
}); });
assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678"); assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
@ -4267,7 +4276,7 @@ mod tests {
// Redo stack gets cleared after an edit. // Redo stack gets cleared after an edit.
now += 2 * group_interval; now += 2 * group_interval;
multibuffer.start_transaction_at(now, cx); multibuffer.start_transaction_at(now, cx);
multibuffer.edit([(0..0, "X")], cx); multibuffer.edit([(0..0, "X")], None, cx);
multibuffer.end_transaction_at(now, cx); multibuffer.end_transaction_at(now, cx);
assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678"); assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
multibuffer.redo(cx); multibuffer.redo(cx);

3
crates/language/Cargo.toml
View file

@ -16,6 +16,7 @@ test-support = [
"text/test-support", "text/test-support",
"tree-sitter-rust", "tree-sitter-rust",
"tree-sitter-typescript", "tree-sitter-typescript",
"settings/test-support",
"util/test-support", "util/test-support",
] ]
@ -27,6 +28,7 @@ fuzzy = { path = "../fuzzy" }
gpui = { path = "../gpui" } gpui = { path = "../gpui" }
lsp = { path = "../lsp" } lsp = { path = "../lsp" }
rpc = { path = "../rpc" } rpc = { path = "../rpc" }
settings = { path = "../settings" }
sum_tree = { path = "../sum_tree" } sum_tree = { path = "../sum_tree" }
text = { path = "../text" } text = { path = "../text" }
theme = { path = "../theme" } theme = { path = "../theme" }
@ -56,6 +58,7 @@ collections = { path = "../collections", features = ["test-support"] }
gpui = { path = "../gpui", features = ["test-support"] } gpui = { path = "../gpui", features = ["test-support"] }
lsp = { path = "../lsp", features = ["test-support"] } lsp = { path = "../lsp", features = ["test-support"] }
text = { path = "../text", features = ["test-support"] } text = { path = "../text", features = ["test-support"] }
settings = { path = "../settings", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] } util = { path = "../util", features = ["test-support"] }
ctor = "0.1" ctor = "0.1"
env_logger = "0.9" env_logger = "0.9"

331
crates/language/src/buffer.rs
View file

@ -14,12 +14,13 @@ use futures::FutureExt as _;
use gpui::{fonts::HighlightStyle, AppContext, Entity, ModelContext, MutableAppContext, Task}; use gpui::{fonts::HighlightStyle, AppContext, Entity, ModelContext, MutableAppContext, Task};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use parking_lot::Mutex; use parking_lot::Mutex;
use settings::Settings;
use similar::{ChangeTag, TextDiff}; use similar::{ChangeTag, TextDiff};
use smol::future::yield_now; use smol::future::yield_now;
use std::{ use std::{
any::Any, any::Any,
cmp::{self, Ordering}, cmp::{self, Ordering},
collections::{BTreeMap, HashMap}, collections::BTreeMap,
ffi::OsStr, ffi::OsStr,
future::Future, future::Future,
iter::{self, Iterator, Peekable}, iter::{self, Iterator, Peekable},
@ -228,12 +229,37 @@ struct SyntaxTree {
version: clock::Global, version: clock::Global,
} }
#[derive(Clone, Debug)]
pub enum AutoindentMode {
/// Indent each line of inserted text.
EachLine,
/// Apply the same indentation adjustment to all of the lines
/// in a given insertion.
Block {
/// The original indentation level of the first line of each
/// insertion, if it has been copied.
original_indent_columns: Vec<u32>,
},
}
#[derive(Clone)] #[derive(Clone)]
struct AutoindentRequest { struct AutoindentRequest {
before_edit: BufferSnapshot, before_edit: BufferSnapshot,
edited: Vec<Anchor>, entries: Vec<AutoindentRequestEntry>,
inserted: Option<Vec<Range<Anchor>>>,
indent_size: IndentSize, indent_size: IndentSize,
is_block_mode: bool,
}
#[derive(Clone)]
struct AutoindentRequestEntry {
/// A range of the buffer whose indentation should be adjusted.
range: Range<Anchor>,
/// Whether or not these lines should be considered brand new, for the
/// purpose of auto-indent. When text is not new, its indentation will
/// only be adjusted if the suggested indentation level has *changed*
/// since the edit was made.
first_line_is_new: bool,
original_indent_column: Option<u32>,
} }
#[derive(Debug)] #[derive(Debug)]
@ -796,19 +822,25 @@ impl Buffer {
Some(async move { Some(async move {
let mut indent_sizes = BTreeMap::new(); let mut indent_sizes = BTreeMap::new();
for request in autoindent_requests { for request in autoindent_requests {
let old_to_new_rows = request // Resolve each edited range to its row in the current buffer and in the
.edited // buffer before this batch of edits.
.iter() let mut row_ranges = Vec::new();
.map(|anchor| anchor.summary::<Point>(&request.before_edit).row) let mut old_to_new_rows = BTreeMap::new();
.zip( for entry in &request.entries {
request let position = entry.range.start;
.edited let new_row = position.to_point(&snapshot).row;
.iter() let new_end_row = entry.range.end.to_point(&snapshot).row + 1;
.map(|anchor| anchor.summary::<Point>(&snapshot).row), if !entry.first_line_is_new {
) let old_row = position.to_point(&request.before_edit).row;
.collect::<BTreeMap<u32, u32>>(); old_to_new_rows.insert(old_row, new_row);
}
row_ranges.push((new_row..new_end_row, entry.original_indent_column));
}
let mut old_suggestions = HashMap::<u32, IndentSize>::default(); // Build a map containing the suggested indentation for each of the edited lines
// with respect to the state of the buffer before these edits. This map is keyed
// by the rows for these lines in the current state of the buffer.
let mut old_suggestions = BTreeMap::<u32, IndentSize>::default();
let old_edited_ranges = let old_edited_ranges =
contiguous_ranges(old_to_new_rows.keys().copied(), max_rows_between_yields); contiguous_ranges(old_to_new_rows.keys().copied(), max_rows_between_yields);
for old_edited_range in old_edited_ranges { for old_edited_range in old_edited_ranges {
@ -819,19 +851,15 @@ impl Buffer {
.flatten(); .flatten();
for (old_row, suggestion) in old_edited_range.zip(suggestions) { for (old_row, suggestion) in old_edited_range.zip(suggestions) {
if let Some(suggestion) = suggestion { if let Some(suggestion) = suggestion {
let mut suggested_indent = old_to_new_rows let suggested_indent = old_to_new_rows
.get(&suggestion.basis_row) .get(&suggestion.basis_row)
.and_then(|from_row| old_suggestions.get(from_row).copied()) .and_then(|from_row| old_suggestions.get(from_row).copied())
.unwrap_or_else(|| { .unwrap_or_else(|| {
request request
.before_edit .before_edit
.indent_size_for_line(suggestion.basis_row) .indent_size_for_line(suggestion.basis_row)
}); })
if suggestion.delta.is_gt() { .with_delta(suggestion.delta, request.indent_size);
suggested_indent += request.indent_size;
} else if suggestion.delta.is_lt() {
suggested_indent -= request.indent_size;
}
old_suggestions old_suggestions
.insert(*old_to_new_rows.get(&old_row).unwrap(), suggested_indent); .insert(*old_to_new_rows.get(&old_row).unwrap(), suggested_indent);
} }
@ -839,10 +867,21 @@ impl Buffer {
yield_now().await; yield_now().await;
} }
// At this point, old_suggestions contains the suggested indentation for all edited lines with respect to the state of the // In block mode, only compute indentation suggestions for the first line
// buffer before the edit, but keyed by the row for these lines after the edits were applied. // of each insertion. Otherwise, compute suggestions for every inserted line.
let new_edited_row_ranges = let new_edited_row_ranges = contiguous_ranges(
contiguous_ranges(old_to_new_rows.values().copied(), max_rows_between_yields); row_ranges.iter().flat_map(|(range, _)| {
if request.is_block_mode {
range.start..range.start + 1
} else {
range.clone()
}
}),
max_rows_between_yields,
);
// Compute new suggestions for each line, but only include them in the result
// if they differ from the old suggestion for that line.
for new_edited_row_range in new_edited_row_ranges { for new_edited_row_range in new_edited_row_ranges {
let suggestions = snapshot let suggestions = snapshot
.suggest_autoindents(new_edited_row_range.clone()) .suggest_autoindents(new_edited_row_range.clone())
@ -850,17 +889,13 @@ impl Buffer {
.flatten(); .flatten();
for (new_row, suggestion) in new_edited_row_range.zip(suggestions) { for (new_row, suggestion) in new_edited_row_range.zip(suggestions) {
if let Some(suggestion) = suggestion { if let Some(suggestion) = suggestion {
let mut suggested_indent = indent_sizes let suggested_indent = indent_sizes
.get(&suggestion.basis_row) .get(&suggestion.basis_row)
.copied() .copied()
.unwrap_or_else(|| { .unwrap_or_else(|| {
snapshot.indent_size_for_line(suggestion.basis_row) snapshot.indent_size_for_line(suggestion.basis_row)
}); })
if suggestion.delta.is_gt() { .with_delta(suggestion.delta, request.indent_size);
suggested_indent += request.indent_size;
} else if suggestion.delta.is_lt() {
suggested_indent -= request.indent_size;
}
if old_suggestions if old_suggestions
.get(&new_row) .get(&new_row)
.map_or(true, |old_indentation| { .map_or(true, |old_indentation| {
@ -874,36 +909,40 @@ impl Buffer {
yield_now().await; yield_now().await;
} }
if let Some(inserted) = request.inserted.as_ref() { // For each block of inserted text, adjust the indentation of the remaining
let inserted_row_ranges = contiguous_ranges( // lines of the block by the same amount as the first line was adjusted.
inserted if request.is_block_mode {
.iter() for (row_range, original_indent_column) in
.map(|range| range.to_point(&snapshot)) row_ranges
.flat_map(|range| range.start.row..range.end.row + 1),
max_rows_between_yields,
);
for inserted_row_range in inserted_row_ranges {
let suggestions = snapshot
.suggest_autoindents(inserted_row_range.clone())
.into_iter() .into_iter()
.flatten(); .filter_map(|(range, original_indent_column)| {
for (row, suggestion) in inserted_row_range.zip(suggestions) { if range.len() > 1 {
if let Some(suggestion) = suggestion { Some((range, original_indent_column?))
let mut suggested_indent = indent_sizes } else {
.get(&suggestion.basis_row) None
}
})
{
let new_indent = indent_sizes
.get(&row_range.start)
.copied() .copied()
.unwrap_or_else(|| { .unwrap_or_else(|| snapshot.indent_size_for_line(row_range.start));
snapshot.indent_size_for_line(suggestion.basis_row) let delta = new_indent.len as i64 - original_indent_column as i64;
if delta != 0 {
for row in row_range.skip(1) {
indent_sizes.entry(row).or_insert_with(|| {
let mut size = snapshot.indent_size_for_line(row);
if size.kind == new_indent.kind {
if delta > 0 {
size.len = size.len + delta as u32;
} else if delta < 0 {
size.len = size.len.saturating_sub(-delta as u32);
}
}
size
}); });
if suggestion.delta.is_gt() {
suggested_indent += request.indent_size;
} else if suggestion.delta.is_lt() {
suggested_indent -= request.indent_size;
}
indent_sizes.insert(row, suggested_indent);
} }
} }
yield_now().await;
} }
} }
} }
@ -945,6 +984,7 @@ impl Buffer {
.take((size.len - current_size.len) as usize) .take((size.len - current_size.len) as usize)
.collect::<String>(), .collect::<String>(),
)], )],
None,
cx, cx,
); );
} else if size.len < current_size.len { } else if size.len < current_size.len {
@ -953,6 +993,7 @@ impl Buffer {
Point::new(row, 0)..Point::new(row, current_size.len - size.len), Point::new(row, 0)..Point::new(row, current_size.len - size.len),
"", "",
)], )],
None,
cx, cx,
); );
} }
@ -990,7 +1031,7 @@ impl Buffer {
match tag { match tag {
ChangeTag::Equal => offset += len, ChangeTag::Equal => offset += len,
ChangeTag::Delete => { ChangeTag::Delete => {
self.edit([(range, "")], cx); self.edit([(range, "")], None, cx);
} }
ChangeTag::Insert => { ChangeTag::Insert => {
self.edit( self.edit(
@ -999,6 +1040,7 @@ impl Buffer {
&diff.new_text[range.start - diff.start_offset &diff.new_text[range.start - diff.start_offset
..range.end - diff.start_offset], ..range.end - diff.start_offset],
)], )],
None,
cx, cx,
); );
offset += len; offset += len;
@ -1135,40 +1177,13 @@ impl Buffer {
where where
T: Into<Arc<str>>, T: Into<Arc<str>>,
{ {
self.edit_internal([(0..self.len(), text)], None, cx) self.edit([(0..self.len(), text)], None, cx)
} }
pub fn edit<I, S, T>( pub fn edit<I, S, T>(
&mut self, &mut self,
edits_iter: I, edits_iter: I,
cx: &mut ModelContext<Self>, autoindent_mode: Option<AutoindentMode>,
) -> Option<clock::Local>
where
I: IntoIterator<Item = (Range<S>, T)>,
S: ToOffset,
T: Into<Arc<str>>,
{
self.edit_internal(edits_iter, None, cx)
}
pub fn edit_with_autoindent<I, S, T>(
&mut self,
edits_iter: I,
indent_size: IndentSize,
cx: &mut ModelContext<Self>,
) -> Option<clock::Local>
where
I: IntoIterator<Item = (Range<S>, T)>,
S: ToOffset,
T: Into<Arc<str>>,
{
self.edit_internal(edits_iter, Some(indent_size), cx)
}
pub fn edit_internal<I, S, T>(
&mut self,
edits_iter: I,
autoindent_size: Option<IndentSize>,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Option<clock::Local> ) -> Option<clock::Local>
where where
@ -1203,58 +1218,79 @@ impl Buffer {
self.start_transaction(); self.start_transaction();
self.pending_autoindent.take(); self.pending_autoindent.take();
let autoindent_request = let autoindent_request = autoindent_mode
self.language .and_then(|mode| self.language.as_ref().map(|_| (self.snapshot(), mode)));
.as_ref()
.and_then(|_| autoindent_size)
.map(|autoindent_size| {
let before_edit = self.snapshot();
let edited = edits
.iter()
.filter_map(|(range, new_text)| {
let start = range.start.to_point(self);
if new_text.starts_with('\n')
&& start.column == self.line_len(start.row)
{
None
} else {
Some(self.anchor_before(range.start))
}
})
.collect();
(before_edit, edited, autoindent_size)
});
let edit_operation = self.text.edit(edits.iter().cloned()); let edit_operation = self.text.edit(edits.iter().cloned());
let edit_id = edit_operation.local_timestamp(); let edit_id = edit_operation.local_timestamp();
if let Some((before_edit, edited, size)) = autoindent_request { if let Some((before_edit, mode)) = autoindent_request {
let mut delta = 0isize; let language_name = self.language().map(|language| language.name());
let settings = cx.global::<Settings>();
let inserted_ranges = edits let indent_size = if settings.hard_tabs(language_name.as_deref()) {
.into_iter() IndentSize::tab()
.zip(&edit_operation.as_edit().unwrap().new_text)
.filter_map(|((range, _), new_text)| {
let first_newline_ix = new_text.find('\n')?;
let new_text_len = new_text.len();
let start = (delta + range.start as isize) as usize + first_newline_ix + 1;
let end = (delta + range.start as isize) as usize + new_text_len;
delta += new_text_len as isize - (range.end as isize - range.start as isize);
Some(self.anchor_before(start)..self.anchor_after(end))
})
.collect::<Vec<Range<Anchor>>>();
let inserted = if inserted_ranges.is_empty() {
None
} else { } else {
Some(inserted_ranges) IndentSize::spaces(settings.tab_size(language_name.as_deref()).get())
}; };
let (start_columns, is_block_mode) = match mode {
AutoindentMode::Block {
original_indent_columns: start_columns,
} => (start_columns, true),
AutoindentMode::EachLine => (Default::default(), false),
};
let mut delta = 0isize;
let entries = edits
.into_iter()
.enumerate()
.zip(&edit_operation.as_edit().unwrap().new_text)
.map(|((ix, (range, _)), new_text)| {
let new_text_len = new_text.len();
let old_start = range.start.to_point(&before_edit);
let new_start = (delta + range.start as isize) as usize;
delta += new_text_len as isize - (range.end as isize - range.start as isize);
let mut range_of_insertion_to_indent = 0..new_text_len;
let mut first_line_is_new = false;
let mut start_column = None;
// When inserting an entire line at the beginning of an existing line,
// treat the insertion as new.
if new_text.contains('\n')
&& old_start.column <= before_edit.indent_size_for_line(old_start.row).len
{
first_line_is_new = true;
}
// When inserting text starting with a newline, avoid auto-indenting the
// previous line.
if new_text[range_of_insertion_to_indent.clone()].starts_with('\n') {
range_of_insertion_to_indent.start += 1;
first_line_is_new = true;
}
// Avoid auto-indenting before the insertion.
if is_block_mode {
start_column = start_columns.get(ix).copied();
if new_text[range_of_insertion_to_indent.clone()].ends_with('\n') {
range_of_insertion_to_indent.end -= 1;
}
}
AutoindentRequestEntry {
first_line_is_new,
original_indent_column: start_column,
range: self.anchor_before(new_start + range_of_insertion_to_indent.start)
..self.anchor_after(new_start + range_of_insertion_to_indent.end),
}
})
.collect();
self.autoindent_requests.push(Arc::new(AutoindentRequest { self.autoindent_requests.push(Arc::new(AutoindentRequest {
before_edit, before_edit,
edited, entries,
inserted, indent_size,
indent_size: size, is_block_mode,
})); }));
} }
@ -1541,7 +1577,7 @@ impl Buffer {
edits.push((range, new_text)); edits.push((range, new_text));
} }
log::info!("mutating buffer {} with {:?}", self.replica_id(), edits); log::info!("mutating buffer {} with {:?}", self.replica_id(), edits);
self.edit(edits, cx); self.edit(edits, None, cx);
} }
pub fn randomly_undo_redo(&mut self, rng: &mut impl rand::Rng, cx: &mut ModelContext<Self>) { pub fn randomly_undo_redo(&mut self, rng: &mut impl rand::Rng, cx: &mut ModelContext<Self>) {
@ -2139,8 +2175,12 @@ impl BufferSnapshot {
} }
pub fn indent_size_for_line(text: &text::BufferSnapshot, row: u32) -> IndentSize { pub fn indent_size_for_line(text: &text::BufferSnapshot, row: u32) -> IndentSize {
indent_size_for_text(text.chars_at(Point::new(row, 0)))
}
pub fn indent_size_for_text(text: impl Iterator<Item = char>) -> IndentSize {
let mut result = IndentSize::spaces(0); let mut result = IndentSize::spaces(0);
for c in text.chars_at(Point::new(row, 0)) { for c in text {
let kind = match c { let kind = match c {
' ' => IndentKind::Space, ' ' => IndentKind::Space,
'\t' => IndentKind::Tab, '\t' => IndentKind::Tab,
@ -2503,23 +2543,24 @@ impl IndentSize {
IndentKind::Tab => '\t', IndentKind::Tab => '\t',
} }
} }
}
impl std::ops::AddAssign for IndentSize { pub fn with_delta(mut self, direction: Ordering, size: IndentSize) -> Self {
fn add_assign(&mut self, other: IndentSize) { match direction {
Ordering::Less => {
if self.kind == size.kind && self.len >= size.len {
self.len -= size.len;
}
}
Ordering::Equal => {}
Ordering::Greater => {
if self.len == 0 { if self.len == 0 {
*self = other; self = size;
} else if self.kind == other.kind { } else if self.kind == size.kind {
self.len += other.len; self.len += size.len;
} }
} }
} }
self
impl std::ops::SubAssign for IndentSize {
fn sub_assign(&mut self, other: IndentSize) {
if self.kind == other.kind && self.len >= other.len {
self.len -= other.len;
}
} }
} }

254
crates/language/src/tests.rs
View file

@ -3,6 +3,7 @@ use clock::ReplicaId;
use collections::BTreeMap; use collections::BTreeMap;
use gpui::{ModelHandle, MutableAppContext}; use gpui::{ModelHandle, MutableAppContext};
use rand::prelude::*; use rand::prelude::*;
use settings::Settings;
use std::{ use std::{
cell::RefCell, cell::RefCell,
env, env,
@ -24,6 +25,7 @@ fn init_logger() {
#[gpui::test] #[gpui::test]
fn test_line_endings(cx: &mut gpui::MutableAppContext) { fn test_line_endings(cx: &mut gpui::MutableAppContext) {
cx.set_global(Settings::test(cx));
cx.add_model(|cx| { cx.add_model(|cx| {
let mut buffer = let mut buffer =
Buffer::new(0, "one\r\ntwo\rthree", cx).with_language(Arc::new(rust_lang()), cx); Buffer::new(0, "one\r\ntwo\rthree", cx).with_language(Arc::new(rust_lang()), cx);
@ -31,12 +33,12 @@ fn test_line_endings(cx: &mut gpui::MutableAppContext) {
assert_eq!(buffer.line_ending(), LineEnding::Windows); assert_eq!(buffer.line_ending(), LineEnding::Windows);
buffer.check_invariants(); buffer.check_invariants();
buffer.edit_with_autoindent( buffer.edit(
[(buffer.len()..buffer.len(), "\r\nfour")], [(buffer.len()..buffer.len(), "\r\nfour")],
IndentSize::spaces(2), Some(AutoindentMode::EachLine),
cx, cx,
); );
buffer.edit([(0..0, "zero\r\n")], cx); buffer.edit([(0..0, "zero\r\n")], None, cx);
assert_eq!(buffer.text(), "zero\none\ntwo\nthree\nfour"); assert_eq!(buffer.text(), "zero\none\ntwo\nthree\nfour");
assert_eq!(buffer.line_ending(), LineEnding::Windows); assert_eq!(buffer.line_ending(), LineEnding::Windows);
buffer.check_invariants(); buffer.check_invariants();
@ -116,7 +118,7 @@ fn test_edit_events(cx: &mut gpui::MutableAppContext) {
// An edit emits an edited event, followed by a dirty changed event, // An edit emits an edited event, followed by a dirty changed event,
// since the buffer was previously in a clean state. // since the buffer was previously in a clean state.
buffer.edit([(2..4, "XYZ")], cx); buffer.edit([(2..4, "XYZ")], None, cx);
// An empty transaction does not emit any events. // An empty transaction does not emit any events.
buffer.start_transaction(); buffer.start_transaction();
@ -125,8 +127,8 @@ fn test_edit_events(cx: &mut gpui::MutableAppContext) {
// A transaction containing two edits emits one edited event. // A transaction containing two edits emits one edited event.
now += Duration::from_secs(1); now += Duration::from_secs(1);
buffer.start_transaction_at(now); buffer.start_transaction_at(now);
buffer.edit([(5..5, "u")], cx); buffer.edit([(5..5, "u")], None, cx);
buffer.edit([(6..6, "w")], cx); buffer.edit([(6..6, "w")], None, cx);
buffer.end_transaction_at(now, cx); buffer.end_transaction_at(now, cx);
// Undoing a transaction emits one edited event. // Undoing a transaction emits one edited event.
@ -226,11 +228,11 @@ async fn test_reparse(cx: &mut gpui::TestAppContext) {
buf.start_transaction(); buf.start_transaction();
let offset = buf.text().find(")").unwrap(); let offset = buf.text().find(")").unwrap();
buf.edit([(offset..offset, "b: C")], cx); buf.edit([(offset..offset, "b: C")], None, cx);
assert!(!buf.is_parsing()); assert!(!buf.is_parsing());
let offset = buf.text().find("}").unwrap(); let offset = buf.text().find("}").unwrap();
buf.edit([(offset..offset, " d; ")], cx); buf.edit([(offset..offset, " d; ")], None, cx);
assert!(!buf.is_parsing()); assert!(!buf.is_parsing());
buf.end_transaction(cx); buf.end_transaction(cx);
@ -255,19 +257,19 @@ async fn test_reparse(cx: &mut gpui::TestAppContext) {
// * add a turbofish to the method call // * add a turbofish to the method call
buffer.update(cx, |buf, cx| { buffer.update(cx, |buf, cx| {
let offset = buf.text().find(";").unwrap(); let offset = buf.text().find(";").unwrap();
buf.edit([(offset..offset, ".e")], cx); buf.edit([(offset..offset, ".e")], None, cx);
assert_eq!(buf.text(), "fn a(b: C) { d.e; }"); assert_eq!(buf.text(), "fn a(b: C) { d.e; }");
assert!(buf.is_parsing()); assert!(buf.is_parsing());
}); });
buffer.update(cx, |buf, cx| { buffer.update(cx, |buf, cx| {
let offset = buf.text().find(";").unwrap(); let offset = buf.text().find(";").unwrap();
buf.edit([(offset..offset, "(f)")], cx); buf.edit([(offset..offset, "(f)")], None, cx);
assert_eq!(buf.text(), "fn a(b: C) { d.e(f); }"); assert_eq!(buf.text(), "fn a(b: C) { d.e(f); }");
assert!(buf.is_parsing()); assert!(buf.is_parsing());
}); });
buffer.update(cx, |buf, cx| { buffer.update(cx, |buf, cx| {
let offset = buf.text().find("(f)").unwrap(); let offset = buf.text().find("(f)").unwrap();
buf.edit([(offset..offset, "::<G>")], cx); buf.edit([(offset..offset, "::<G>")], None, cx);
assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }"); assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
assert!(buf.is_parsing()); assert!(buf.is_parsing());
}); });
@ -545,6 +547,7 @@ async fn test_symbols_containing(cx: &mut gpui::TestAppContext) {
#[gpui::test] #[gpui::test]
fn test_enclosing_bracket_ranges(cx: &mut MutableAppContext) { fn test_enclosing_bracket_ranges(cx: &mut MutableAppContext) {
cx.set_global(Settings::test(cx));
let buffer = cx.add_model(|cx| { let buffer = cx.add_model(|cx| {
let text = " let text = "
mod x { mod x {
@ -620,34 +623,37 @@ fn test_range_for_syntax_ancestor(cx: &mut MutableAppContext) {
#[gpui::test] #[gpui::test]
fn test_autoindent_with_soft_tabs(cx: &mut MutableAppContext) { fn test_autoindent_with_soft_tabs(cx: &mut MutableAppContext) {
let settings = Settings::test(cx);
cx.set_global(settings);
cx.add_model(|cx| { cx.add_model(|cx| {
let text = "fn a() {}"; let text = "fn a() {}";
let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx); let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
buffer.edit_with_autoindent([(8..8, "\n\n")], IndentSize::spaces(4), cx); buffer.edit([(8..8, "\n\n")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "fn a() {\n \n}"); assert_eq!(buffer.text(), "fn a() {\n \n}");
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(1, 4)..Point::new(1, 4), "b()\n")], [(Point::new(1, 4)..Point::new(1, 4), "b()\n")],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!(buffer.text(), "fn a() {\n b()\n \n}"); assert_eq!(buffer.text(), "fn a() {\n b()\n \n}");
// Create a field expression on a new line, causing that line // Create a field expression on a new line, causing that line
// to be indented. // to be indented.
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(2, 4)..Point::new(2, 4), ".c")], [(Point::new(2, 4)..Point::new(2, 4), ".c")],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!(buffer.text(), "fn a() {\n b()\n .c\n}"); assert_eq!(buffer.text(), "fn a() {\n b()\n .c\n}");
// Remove the dot so that the line is no longer a field expression, // Remove the dot so that the line is no longer a field expression,
// causing the line to be outdented. // causing the line to be outdented.
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(2, 8)..Point::new(2, 9), "")], [(Point::new(2, 8)..Point::new(2, 9), "")],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!(buffer.text(), "fn a() {\n b()\n c\n}"); assert_eq!(buffer.text(), "fn a() {\n b()\n c\n}");
@ -658,34 +664,38 @@ fn test_autoindent_with_soft_tabs(cx: &mut MutableAppContext) {
#[gpui::test] #[gpui::test]
fn test_autoindent_with_hard_tabs(cx: &mut MutableAppContext) { fn test_autoindent_with_hard_tabs(cx: &mut MutableAppContext) {
let mut settings = Settings::test(cx);
settings.editor_overrides.hard_tabs = Some(true);
cx.set_global(settings);
cx.add_model(|cx| { cx.add_model(|cx| {
let text = "fn a() {}"; let text = "fn a() {}";
let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx); let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
buffer.edit_with_autoindent([(8..8, "\n\n")], IndentSize::tab(), cx); buffer.edit([(8..8, "\n\n")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "fn a() {\n\t\n}"); assert_eq!(buffer.text(), "fn a() {\n\t\n}");
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(1, 1)..Point::new(1, 1), "b()\n")], [(Point::new(1, 1)..Point::new(1, 1), "b()\n")],
IndentSize::tab(), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!(buffer.text(), "fn a() {\n\tb()\n\t\n}"); assert_eq!(buffer.text(), "fn a() {\n\tb()\n\t\n}");
// Create a field expression on a new line, causing that line // Create a field expression on a new line, causing that line
// to be indented. // to be indented.
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(2, 1)..Point::new(2, 1), ".c")], [(Point::new(2, 1)..Point::new(2, 1), ".c")],
IndentSize::tab(), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!(buffer.text(), "fn a() {\n\tb()\n\t\t.c\n}"); assert_eq!(buffer.text(), "fn a() {\n\tb()\n\t\t.c\n}");
// Remove the dot so that the line is no longer a field expression, // Remove the dot so that the line is no longer a field expression,
// causing the line to be outdented. // causing the line to be outdented.
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(2, 2)..Point::new(2, 3), "")], [(Point::new(2, 2)..Point::new(2, 3), "")],
IndentSize::tab(), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!(buffer.text(), "fn a() {\n\tb()\n\tc\n}"); assert_eq!(buffer.text(), "fn a() {\n\tb()\n\tc\n}");
@ -696,6 +706,9 @@ fn test_autoindent_with_hard_tabs(cx: &mut MutableAppContext) {
#[gpui::test] #[gpui::test]
fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut MutableAppContext) { fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut MutableAppContext) {
let settings = Settings::test(cx);
cx.set_global(settings);
cx.add_model(|cx| { cx.add_model(|cx| {
let text = " let text = "
fn a() { fn a() {
@ -709,12 +722,12 @@ fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut Muta
// Lines 2 and 3 don't match the indentation suggestion. When editing these lines, // Lines 2 and 3 don't match the indentation suggestion. When editing these lines,
// their indentation is not adjusted. // their indentation is not adjusted.
buffer.edit_with_autoindent( buffer.edit(
[ [
(empty(Point::new(1, 1)), "()"), (empty(Point::new(1, 1)), "()"),
(empty(Point::new(2, 1)), "()"), (empty(Point::new(2, 1)), "()"),
], ],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!( assert_eq!(
@ -730,12 +743,12 @@ fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut Muta
// When appending new content after these lines, the indentation is based on the // When appending new content after these lines, the indentation is based on the
// preceding lines' actual indentation. // preceding lines' actual indentation.
buffer.edit_with_autoindent( buffer.edit(
[ [
(empty(Point::new(1, 1)), "\n.f\n.g"), (empty(Point::new(1, 1)), "\n.f\n.g"),
(empty(Point::new(2, 1)), "\n.f\n.g"), (empty(Point::new(2, 1)), "\n.f\n.g"),
], ],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!( assert_eq!(
@ -756,26 +769,54 @@ fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut Muta
}); });
cx.add_model(|cx| { cx.add_model(|cx| {
let text = "fn a() {\n {\n b()?\n }\n\n Ok(())\n}"; let text = "
fn a() {
{
b()?
}
Ok(())
}
"
.unindent();
let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx); let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
buffer.edit_with_autoindent(
// Delete a closing curly brace changes the suggested indent for the line.
buffer.edit(
[(Point::new(3, 4)..Point::new(3, 5), "")], [(Point::new(3, 4)..Point::new(3, 5), "")],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
"fn a() {\n {\n b()?\n \n\n Ok(())\n}" "
fn a() {
{
b()?
|
Ok(())
}
"
.replace("|", "") // included in the string to preserve trailing whites
.unindent()
); );
buffer.edit_with_autoindent( // Manually editing the leading whitespace
buffer.edit(
[(Point::new(3, 0)..Point::new(3, 12), "")], [(Point::new(3, 0)..Point::new(3, 12), "")],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
"fn a() {\n {\n b()?\n\n\n Ok(())\n}" "
fn a() {
{
b()?
Ok(())
}
"
.unindent()
); );
buffer buffer
}); });
@ -783,6 +824,7 @@ fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut Muta
#[gpui::test] #[gpui::test]
fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppContext) { fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppContext) {
cx.set_global(Settings::test(cx));
cx.add_model(|cx| { cx.add_model(|cx| {
let text = " let text = "
fn a() {} fn a() {}
@ -791,7 +833,7 @@ fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppConte
let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx); let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
buffer.edit_with_autoindent([(5..5, "\nb")], IndentSize::spaces(4), cx); buffer.edit([(5..5, "\nb")], Some(AutoindentMode::EachLine), cx);
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
" "
@ -803,9 +845,9 @@ fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppConte
// The indentation suggestion changed because `@end` node (a close paren) // The indentation suggestion changed because `@end` node (a close paren)
// is now at the beginning of the line. // is now at the beginning of the line.
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(1, 4)..Point::new(1, 5), "")], [(Point::new(1, 4)..Point::new(1, 5), "")],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!( assert_eq!(
@ -823,17 +865,137 @@ fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppConte
#[gpui::test] #[gpui::test]
fn test_autoindent_with_edit_at_end_of_buffer(cx: &mut MutableAppContext) { fn test_autoindent_with_edit_at_end_of_buffer(cx: &mut MutableAppContext) {
cx.set_global(Settings::test(cx));
cx.add_model(|cx| { cx.add_model(|cx| {
let text = "a\nb"; let text = "a\nb";
let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx); let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
buffer.edit_with_autoindent([(0..1, "\n"), (2..3, "\n")], IndentSize::spaces(4), cx); buffer.edit(
[(0..1, "\n"), (2..3, "\n")],
Some(AutoindentMode::EachLine),
cx,
);
assert_eq!(buffer.text(), "\n\n\n"); assert_eq!(buffer.text(), "\n\n\n");
buffer buffer
}); });
} }
#[gpui::test] #[gpui::test]
fn test_autoindent_disabled(cx: &mut MutableAppContext) { fn test_autoindent_multi_line_insertion(cx: &mut MutableAppContext) {
cx.set_global(Settings::test(cx));
cx.add_model(|cx| {
let text = "
const a: usize = 1;
fn b() {
if c {
let d = 2;
}
}
"
.unindent();
let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
buffer.edit(
[(Point::new(3, 0)..Point::new(3, 0), "e(\n f()\n);\n")],
Some(AutoindentMode::EachLine),
cx,
);
assert_eq!(
buffer.text(),
"
const a: usize = 1;
fn b() {
if c {
e(
f()
);
let d = 2;
}
}
"
.unindent()
);
buffer
});
}
#[gpui::test]
fn test_autoindent_block_mode(cx: &mut MutableAppContext) {
cx.set_global(Settings::test(cx));
cx.add_model(|cx| {
let text = r#"
fn a() {
b();
}
"#
.unindent();
let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
let inserted_text = r#"
"
c
d
e
"
"#
.unindent();
// Insert the block at column zero. The entire block is indented
// so that the first line matches the previous line's indentation.
buffer.edit(
[(Point::new(2, 0)..Point::new(2, 0), inserted_text.clone())],
Some(AutoindentMode::Block {
original_indent_columns: vec![0],
}),
cx,
);
assert_eq!(
buffer.text(),
r#"
fn a() {
b();
"
c
d
e
"
}
"#
.unindent()
);
// Insert the block at a deeper indent level. The entire block is outdented.
buffer.undo(cx);
buffer.edit([(Point::new(2, 0)..Point::new(2, 0), " ")], None, cx);
buffer.edit(
[(Point::new(2, 8)..Point::new(2, 8), inserted_text.clone())],
Some(AutoindentMode::Block {
original_indent_columns: vec![0],
}),
cx,
);
assert_eq!(
buffer.text(),
r#"
fn a() {
b();
"
c
d
e
"
}
"#
.unindent()
);
buffer
});
}
#[gpui::test]
fn test_autoindent_language_without_indents_query(cx: &mut MutableAppContext) {
cx.set_global(Settings::test(cx));
cx.add_model(|cx| { cx.add_model(|cx| {
let text = " let text = "
* one * one
@ -853,9 +1015,9 @@ fn test_autoindent_disabled(cx: &mut MutableAppContext) {
)), )),
cx, cx,
); );
buffer.edit_with_autoindent( buffer.edit(
[(Point::new(3, 0)..Point::new(3, 0), "\n")], [(Point::new(3, 0)..Point::new(3, 0), "\n")],
IndentSize::spaces(4), Some(AutoindentMode::EachLine),
cx, cx,
); );
assert_eq!( assert_eq!(
@ -879,18 +1041,18 @@ fn test_serialization(cx: &mut gpui::MutableAppContext) {
let buffer1 = cx.add_model(|cx| { let buffer1 = cx.add_model(|cx| {
let mut buffer = Buffer::new(0, "abc", cx); let mut buffer = Buffer::new(0, "abc", cx);
buffer.edit([(3..3, "D")], cx); buffer.edit([(3..3, "D")], None, cx);
now += Duration::from_secs(1); now += Duration::from_secs(1);
buffer.start_transaction_at(now); buffer.start_transaction_at(now);
buffer.edit([(4..4, "E")], cx); buffer.edit([(4..4, "E")], None, cx);
buffer.end_transaction_at(now, cx); buffer.end_transaction_at(now, cx);
assert_eq!(buffer.text(), "abcDE"); assert_eq!(buffer.text(), "abcDE");
buffer.undo(cx); buffer.undo(cx);
assert_eq!(buffer.text(), "abcD"); assert_eq!(buffer.text(), "abcD");
buffer.edit([(4..4, "F")], cx); buffer.edit([(4..4, "F")], None, cx);
assert_eq!(buffer.text(), "abcDF"); assert_eq!(buffer.text(), "abcDF");
buffer buffer
}); });

6
crates/project/src/project.rs
View file

@ -3168,7 +3168,7 @@ impl Project {
buffer.finalize_last_transaction(); buffer.finalize_last_transaction();
buffer.start_transaction(); buffer.start_transaction();
for (range, text) in edits { for (range, text) in edits {
buffer.edit([(range, text)], cx); buffer.edit([(range, text)], None, cx);
} }
if buffer.end_transaction(cx).is_some() { if buffer.end_transaction(cx).is_some() {
let transaction = buffer.finalize_last_transaction().unwrap().clone(); let transaction = buffer.finalize_last_transaction().unwrap().clone();
@ -3663,7 +3663,7 @@ impl Project {
buffer.finalize_last_transaction(); buffer.finalize_last_transaction();
buffer.start_transaction(); buffer.start_transaction();
for (range, text) in edits { for (range, text) in edits {
buffer.edit([(range, text)], cx); buffer.edit([(range, text)], None, cx);
} }
let transaction = if buffer.end_transaction(cx).is_some() { let transaction = if buffer.end_transaction(cx).is_some() {
let transaction = buffer.finalize_last_transaction().unwrap().clone(); let transaction = buffer.finalize_last_transaction().unwrap().clone();
@ -4023,7 +4023,7 @@ impl Project {
buffer.finalize_last_transaction(); buffer.finalize_last_transaction();
buffer.start_transaction(); buffer.start_transaction();
for (range, text) in edits { for (range, text) in edits {
buffer.edit([(range, text)], cx); buffer.edit([(range, text)], None, cx);
} }
let transaction = if buffer.end_transaction(cx).is_some() { let transaction = if buffer.end_transaction(cx).is_some() {
let transaction = buffer.finalize_last_transaction().unwrap().clone(); let transaction = buffer.finalize_last_transaction().unwrap().clone();

51
crates/project/src/project_tests.rs
View file

@ -169,7 +169,7 @@ async fn test_managing_language_servers(
}); });
// Edit a buffer. The changes are reported to the language server. // Edit a buffer. The changes are reported to the language server.
rust_buffer.update(cx, |buffer, cx| buffer.edit([(16..16, "2")], cx)); rust_buffer.update(cx, |buffer, cx| buffer.edit([(16..16, "2")], None, cx));
assert_eq!( assert_eq!(
fake_rust_server fake_rust_server
.receive_notification::<lsp::notification::DidChangeTextDocument>() .receive_notification::<lsp::notification::DidChangeTextDocument>()
@ -226,8 +226,10 @@ async fn test_managing_language_servers(
}); });
// Changes are reported only to servers matching the buffer's language. // Changes are reported only to servers matching the buffer's language.
toml_buffer.update(cx, |buffer, cx| buffer.edit([(5..5, "23")], cx)); toml_buffer.update(cx, |buffer, cx| buffer.edit([(5..5, "23")], None, cx));
rust_buffer2.update(cx, |buffer, cx| buffer.edit([(0..0, "let x = 1;")], cx)); rust_buffer2.update(cx, |buffer, cx| {
buffer.edit([(0..0, "let x = 1;")], None, cx)
});
assert_eq!( assert_eq!(
fake_rust_server fake_rust_server
.receive_notification::<lsp::notification::DidChangeTextDocument>() .receive_notification::<lsp::notification::DidChangeTextDocument>()
@ -348,7 +350,7 @@ async fn test_managing_language_servers(
}); });
// The renamed file's version resets after changing language server. // The renamed file's version resets after changing language server.
rust_buffer2.update(cx, |buffer, cx| buffer.edit([(0..0, "// ")], cx)); rust_buffer2.update(cx, |buffer, cx| buffer.edit([(0..0, "// ")], None, cx));
assert_eq!( assert_eq!(
fake_json_server fake_json_server
.receive_notification::<lsp::notification::DidChangeTextDocument>() .receive_notification::<lsp::notification::DidChangeTextDocument>()
@ -972,7 +974,7 @@ async fn test_transforming_diagnostics(cx: &mut gpui::TestAppContext) {
.await; .await;
// Edit the buffer, moving the content down // Edit the buffer, moving the content down
buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "\n\n")], cx)); buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "\n\n")], None, cx));
let change_notification_1 = fake_server let change_notification_1 = fake_server
.receive_notification::<lsp::notification::DidChangeTextDocument>() .receive_notification::<lsp::notification::DidChangeTextDocument>()
.await; .await;
@ -1137,9 +1139,13 @@ async fn test_transforming_diagnostics(cx: &mut gpui::TestAppContext) {
// Keep editing the buffer and ensure disk-based diagnostics get translated according to the // Keep editing the buffer and ensure disk-based diagnostics get translated according to the
// changes since the last save. // changes since the last save.
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.edit([(Point::new(2, 0)..Point::new(2, 0), " ")], cx); buffer.edit([(Point::new(2, 0)..Point::new(2, 0), " ")], None, cx);
buffer.edit([(Point::new(2, 8)..Point::new(2, 10), "(x: usize)")], cx); buffer.edit(
buffer.edit([(Point::new(3, 10)..Point::new(3, 10), "xxx")], cx); [(Point::new(2, 8)..Point::new(2, 10), "(x: usize)")],
None,
cx,
);
buffer.edit([(Point::new(3, 10)..Point::new(3, 10), "xxx")], None, cx);
}); });
let change_notification_2 = fake_server let change_notification_2 = fake_server
.receive_notification::<lsp::notification::DidChangeTextDocument>() .receive_notification::<lsp::notification::DidChangeTextDocument>()
@ -1330,6 +1336,7 @@ async fn test_edits_from_lsp_with_past_version(cx: &mut gpui::TestAppContext) {
Point::new(0, 0)..Point::new(0, 0), Point::new(0, 0)..Point::new(0, 0),
"// above first function\n", "// above first function\n",
)], )],
None,
cx, cx,
); );
buffer.edit( buffer.edit(
@ -1337,6 +1344,7 @@ async fn test_edits_from_lsp_with_past_version(cx: &mut gpui::TestAppContext) {
Point::new(2, 0)..Point::new(2, 0), Point::new(2, 0)..Point::new(2, 0),
" // inside first function\n", " // inside first function\n",
)], )],
None,
cx, cx,
); );
buffer.edit( buffer.edit(
@ -1344,6 +1352,7 @@ async fn test_edits_from_lsp_with_past_version(cx: &mut gpui::TestAppContext) {
Point::new(6, 4)..Point::new(6, 4), Point::new(6, 4)..Point::new(6, 4),
"// inside second function ", "// inside second function ",
)], )],
None,
cx, cx,
); );
@ -1405,7 +1414,7 @@ async fn test_edits_from_lsp_with_past_version(cx: &mut gpui::TestAppContext) {
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
for (range, new_text) in edits { for (range, new_text) in edits {
buffer.edit([(range, new_text)], cx); buffer.edit([(range, new_text)], None, cx);
} }
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
@ -1517,7 +1526,7 @@ async fn test_edits_from_lsp_with_edits_on_adjacent_lines(cx: &mut gpui::TestApp
); );
for (range, new_text) in edits { for (range, new_text) in edits {
buffer.edit([(range, new_text)], cx); buffer.edit([(range, new_text)], None, cx);
} }
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
@ -1620,7 +1629,7 @@ async fn test_invalid_edits_from_lsp(cx: &mut gpui::TestAppContext) {
); );
for (range, new_text) in edits { for (range, new_text) in edits {
buffer.edit([(range, new_text)], cx); buffer.edit([(range, new_text)], None, cx);
} }
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
@ -2025,7 +2034,7 @@ async fn test_save_file(cx: &mut gpui::TestAppContext) {
buffer buffer
.update(cx, |buffer, cx| { .update(cx, |buffer, cx| {
assert_eq!(buffer.text(), "the old contents"); assert_eq!(buffer.text(), "the old contents");
buffer.edit([(0..0, "a line of text.\n".repeat(10 * 1024))], cx); buffer.edit([(0..0, "a line of text.\n".repeat(10 * 1024))], None, cx);
buffer.save(cx) buffer.save(cx)
}) })
.await .await
@ -2053,7 +2062,7 @@ async fn test_save_in_single_file_worktree(cx: &mut gpui::TestAppContext) {
.unwrap(); .unwrap();
buffer buffer
.update(cx, |buffer, cx| { .update(cx, |buffer, cx| {
buffer.edit([(0..0, "a line of text.\n".repeat(10 * 1024))], cx); buffer.edit([(0..0, "a line of text.\n".repeat(10 * 1024))], None, cx);
buffer.save(cx) buffer.save(cx)
}) })
.await .await
@ -2073,7 +2082,7 @@ async fn test_save_as(cx: &mut gpui::TestAppContext) {
project.create_buffer("", None, cx).unwrap() project.create_buffer("", None, cx).unwrap()
}); });
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.edit([(0..0, "abc")], cx); buffer.edit([(0..0, "abc")], None, cx);
assert!(buffer.is_dirty()); assert!(buffer.is_dirty());
assert!(!buffer.has_conflict()); assert!(!buffer.has_conflict());
}); });
@ -2329,7 +2338,7 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
assert!(!buffer.is_dirty()); assert!(!buffer.is_dirty());
assert!(events.borrow().is_empty()); assert!(events.borrow().is_empty());
buffer.edit([(1..2, "")], cx); buffer.edit([(1..2, "")], None, cx);
}); });
// after the first edit, the buffer is dirty, and emits a dirtied event. // after the first edit, the buffer is dirty, and emits a dirtied event.
@ -2356,8 +2365,8 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
assert_eq!(*events.borrow(), &[language::Event::Saved]); assert_eq!(*events.borrow(), &[language::Event::Saved]);
events.borrow_mut().clear(); events.borrow_mut().clear();
buffer.edit([(1..1, "B")], cx); buffer.edit([(1..1, "B")], None, cx);
buffer.edit([(2..2, "D")], cx); buffer.edit([(2..2, "D")], None, cx);
}); });
// after editing again, the buffer is dirty, and emits another dirty event. // after editing again, the buffer is dirty, and emits another dirty event.
@ -2376,7 +2385,7 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
// After restoring the buffer to its previously-saved state, // After restoring the buffer to its previously-saved state,
// the buffer is not considered dirty anymore. // the buffer is not considered dirty anymore.
buffer.edit([(1..3, "")], cx); buffer.edit([(1..3, "")], None, cx);
assert!(buffer.text() == "ac"); assert!(buffer.text() == "ac");
assert!(!buffer.is_dirty()); assert!(!buffer.is_dirty());
}); });
@ -2427,7 +2436,7 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
}); });
buffer3.update(cx, |buffer, cx| { buffer3.update(cx, |buffer, cx| {
buffer.edit([(0..0, "x")], cx); buffer.edit([(0..0, "x")], None, cx);
}); });
events.borrow_mut().clear(); events.borrow_mut().clear();
fs.remove_file("/dir/file3".as_ref(), Default::default()) fs.remove_file("/dir/file3".as_ref(), Default::default())
@ -2495,7 +2504,7 @@ async fn test_buffer_file_changes_on_disk(cx: &mut gpui::TestAppContext) {
// Modify the buffer // Modify the buffer
buffer.update(cx, |buffer, cx| { buffer.update(cx, |buffer, cx| {
buffer.edit([(0..0, " ")], cx); buffer.edit([(0..0, " ")], None, cx);
assert!(buffer.is_dirty()); assert!(buffer.is_dirty());
assert!(!buffer.has_conflict()); assert!(!buffer.has_conflict());
}); });
@ -2986,7 +2995,7 @@ async fn test_search(cx: &mut gpui::TestAppContext) {
.unwrap(); .unwrap();
buffer_4.update(cx, |buffer, cx| { buffer_4.update(cx, |buffer, cx| {
let text = "two::TWO"; let text = "two::TWO";
buffer.edit([(20..28, text), (31..43, text)], cx); buffer.edit([(20..28, text), (31..43, text)], None, cx);
}); });
assert_eq!( assert_eq!(

2
crates/search/src/buffer_search.rs
View file

@ -260,7 +260,7 @@ impl BufferSearchBar {
self.query_editor.update(cx, |query_editor, cx| { self.query_editor.update(cx, |query_editor, cx| {
query_editor.buffer().update(cx, |query_buffer, cx| { query_editor.buffer().update(cx, |query_buffer, cx| {
let len = query_buffer.len(cx); let len = query_buffer.len(cx);
query_buffer.edit([(0..len, query)], cx); query_buffer.edit([(0..len, query)], None, cx);
}); });
}); });
} }

4
crates/vim/src/normal.rs
View file

@ -13,7 +13,7 @@ use change::init as change_init;
use collections::HashSet; use collections::HashSet;
use editor::{Autoscroll, Bias, ClipboardSelection, DisplayPoint}; use editor::{Autoscroll, Bias, ClipboardSelection, DisplayPoint};
use gpui::{actions, MutableAppContext, ViewContext}; use gpui::{actions, MutableAppContext, ViewContext};
use language::{Point, SelectionGoal}; use language::{AutoindentMode, Point, SelectionGoal};
use workspace::Workspace; use workspace::Workspace;
use self::{change::change_over, delete::delete_over, yank::yank_over}; use self::{change::change_over, delete::delete_over, yank::yank_over};
@ -278,7 +278,7 @@ fn paste(_: &mut Workspace, _: &Paste, cx: &mut ViewContext<Workspace>) {
} }
} }
drop(snapshot); drop(snapshot);
buffer.edit_with_autoindent(edits, cx); buffer.edit(edits, Some(AutoindentMode::EachLine), cx);
}); });
editor.change_selections(Some(Autoscroll::Fit), cx, |s| { editor.change_selections(Some(Autoscroll::Fit), cx, |s| {

1
crates/vim/src/utils.rs
View file

@ -17,6 +17,7 @@ pub fn copy_selections_content(editor: &mut Editor, linewise: bool, cx: &mut Mut
clipboard_selections.push(ClipboardSelection { clipboard_selections.push(ClipboardSelection {
len: text.len() - initial_len, len: text.len() - initial_len,
is_entire_line: linewise, is_entire_line: linewise,
first_line_indent: buffer.indent_size_for_line(start.row).len,
}); });
} }
} }

4
crates/vim/src/visual.rs
View file

@ -3,7 +3,7 @@ use std::borrow::Cow;
use collections::HashMap; use collections::HashMap;
use editor::{display_map::ToDisplayPoint, Autoscroll, Bias, ClipboardSelection}; use editor::{display_map::ToDisplayPoint, Autoscroll, Bias, ClipboardSelection};
use gpui::{actions, MutableAppContext, ViewContext}; use gpui::{actions, MutableAppContext, ViewContext};
use language::SelectionGoal; use language::{AutoindentMode, SelectionGoal};
use workspace::Workspace; use workspace::Workspace;
use crate::{motion::Motion, state::Mode, utils::copy_selections_content, Vim}; use crate::{motion::Motion, state::Mode, utils::copy_selections_content, Vim};
@ -254,7 +254,7 @@ pub fn paste(_: &mut Workspace, _: &VisualPaste, cx: &mut ViewContext<Workspace>
} }
} }
drop(snapshot); drop(snapshot);
buffer.edit_with_autoindent(edits, cx); buffer.edit(edits, Some(AutoindentMode::EachLine), cx);
}); });
editor.change_selections(Some(Autoscroll::Fit), cx, |s| { editor.change_selections(Some(Autoscroll::Fit), cx, |s| {

15
crates/zed/src/languages/c.rs
View file

@ -249,34 +249,37 @@ impl super::LspAdapter for CLspAdapter {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use gpui::MutableAppContext; use gpui::MutableAppContext;
use language::{Buffer, IndentSize}; use language::{AutoindentMode, Buffer};
use settings::Settings;
use std::sync::Arc; use std::sync::Arc;
#[gpui::test] #[gpui::test]
fn test_c_autoindent(cx: &mut MutableAppContext) { fn test_c_autoindent(cx: &mut MutableAppContext) {
cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX); cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
let language = crate::languages::language("c", tree_sitter_c::language(), None); let language = crate::languages::language("c", tree_sitter_c::language(), None);
cx.add_model(|cx| { cx.add_model(|cx| {
let mut buffer = Buffer::new(0, "", cx).with_language(Arc::new(language), cx); let mut buffer = Buffer::new(0, "", cx).with_language(Arc::new(language), cx);
let size = IndentSize::spaces(2);
// empty function // empty function
buffer.edit_with_autoindent([(0..0, "int main() {}")], size, cx); buffer.edit([(0..0, "int main() {}")], None, cx);
// indent inside braces // indent inside braces
let ix = buffer.len() - 1; let ix = buffer.len() - 1;
buffer.edit_with_autoindent([(ix..ix, "\n\n")], size, cx); buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "int main() {\n \n}"); assert_eq!(buffer.text(), "int main() {\n \n}");
// indent body of single-statement if statement // indent body of single-statement if statement
let ix = buffer.len() - 2; let ix = buffer.len() - 2;
buffer.edit_with_autoindent([(ix..ix, "if (a)\nb;")], size, cx); buffer.edit([(ix..ix, "if (a)\nb;")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "int main() {\n if (a)\n b;\n}"); assert_eq!(buffer.text(), "int main() {\n if (a)\n b;\n}");
// indent inside field expression // indent inside field expression
let ix = buffer.len() - 3; let ix = buffer.len() - 3;
buffer.edit_with_autoindent([(ix..ix, "\n.c")], size, cx); buffer.edit([(ix..ix, "\n.c")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "int main() {\n if (a)\n b\n .c;\n}"); assert_eq!(buffer.text(), "int main() {\n if (a)\n b\n .c;\n}");
buffer buffer

23
crates/zed/src/languages/python.rs
View file

@ -147,20 +147,23 @@ impl LspAdapter for PythonLspAdapter {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use gpui::{ModelContext, MutableAppContext}; use gpui::{ModelContext, MutableAppContext};
use language::{Buffer, IndentSize}; use language::{AutoindentMode, Buffer};
use settings::Settings;
use std::sync::Arc; use std::sync::Arc;
#[gpui::test] #[gpui::test]
fn test_python_autoindent(cx: &mut MutableAppContext) { fn test_python_autoindent(cx: &mut MutableAppContext) {
cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX); cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
let language = crate::languages::language("python", tree_sitter_python::language(), None); let language = crate::languages::language("python", tree_sitter_python::language(), None);
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
cx.add_model(|cx| { cx.add_model(|cx| {
let mut buffer = Buffer::new(0, "", cx).with_language(Arc::new(language), cx); let mut buffer = Buffer::new(0, "", cx).with_language(Arc::new(language), cx);
let size = IndentSize::spaces(2);
let append = |buffer: &mut Buffer, text: &str, cx: &mut ModelContext<Buffer>| { let append = |buffer: &mut Buffer, text: &str, cx: &mut ModelContext<Buffer>| {
let ix = buffer.len(); let ix = buffer.len();
buffer.edit_with_autoindent([(ix..ix, text)], size, cx); buffer.edit([(ix..ix, text)], Some(AutoindentMode::EachLine), cx);
}; };
// indent after "def():" // indent after "def():"
@ -204,7 +207,11 @@ mod tests {
// dedent the closing paren if it is shifted to the beginning of the line // dedent the closing paren if it is shifted to the beginning of the line
let argument_ix = buffer.text().find("1").unwrap(); let argument_ix = buffer.text().find("1").unwrap();
buffer.edit_with_autoindent([(argument_ix..argument_ix + 1, "")], size, cx); buffer.edit(
[(argument_ix..argument_ix + 1, "")],
Some(AutoindentMode::EachLine),
cx,
);
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
"def a():\n \n if a:\n b()\n else:\n foo(\n )" "def a():\n \n if a:\n b()\n else:\n foo(\n )"
@ -219,7 +226,11 @@ mod tests {
// manually outdent the last line // manually outdent the last line
let end_whitespace_ix = buffer.len() - 4; let end_whitespace_ix = buffer.len() - 4;
buffer.edit_with_autoindent([(end_whitespace_ix..buffer.len(), "")], size, cx); buffer.edit(
[(end_whitespace_ix..buffer.len(), "")],
Some(AutoindentMode::EachLine),
cx,
);
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
"def a():\n \n if a:\n b()\n else:\n foo(\n )\n" "def a():\n \n if a:\n b()\n else:\n foo(\n )\n"
@ -233,7 +244,7 @@ mod tests {
); );
// reset to a simple if statement // reset to a simple if statement
buffer.edit([(0..buffer.len(), "if a:\n b(\n )")], cx); buffer.edit([(0..buffer.len(), "if a:\n b(\n )")], None, cx);
// dedent "else" on the line after a closing paren // dedent "else" on the line after a closing paren
append(&mut buffer, "\n else:\n", cx); append(&mut buffer, "\n else:\n", cx);

21
crates/zed/src/languages/rust.rs
View file

@ -257,6 +257,7 @@ mod tests {
use super::*; use super::*;
use crate::languages::{language, CachedLspAdapter}; use crate::languages::{language, CachedLspAdapter};
use gpui::{color::Color, MutableAppContext}; use gpui::{color::Color, MutableAppContext};
use settings::Settings;
use theme::SyntaxTheme; use theme::SyntaxTheme;
#[gpui::test] #[gpui::test]
@ -433,37 +434,39 @@ mod tests {
fn test_rust_autoindent(cx: &mut MutableAppContext) { fn test_rust_autoindent(cx: &mut MutableAppContext) {
cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX); cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
let language = crate::languages::language("rust", tree_sitter_rust::language(), None); let language = crate::languages::language("rust", tree_sitter_rust::language(), None);
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
cx.add_model(|cx| { cx.add_model(|cx| {
let mut buffer = Buffer::new(0, "", cx).with_language(Arc::new(language), cx); let mut buffer = Buffer::new(0, "", cx).with_language(Arc::new(language), cx);
let size = IndentSize::spaces(2);
// indent between braces // indent between braces
buffer.set_text("fn a() {}", cx); buffer.set_text("fn a() {}", cx);
let ix = buffer.len() - 1; let ix = buffer.len() - 1;
buffer.edit_with_autoindent([(ix..ix, "\n\n")], size, cx); buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "fn a() {\n \n}"); assert_eq!(buffer.text(), "fn a() {\n \n}");
// indent between braces, even after empty lines // indent between braces, even after empty lines
buffer.set_text("fn a() {\n\n\n}", cx); buffer.set_text("fn a() {\n\n\n}", cx);
let ix = buffer.len() - 2; let ix = buffer.len() - 2;
buffer.edit_with_autoindent([(ix..ix, "\n")], size, cx); buffer.edit([(ix..ix, "\n")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "fn a() {\n\n\n \n}"); assert_eq!(buffer.text(), "fn a() {\n\n\n \n}");
// indent a line that continues a field expression // indent a line that continues a field expression
buffer.set_text("fn a() {\n \n}", cx); buffer.set_text("fn a() {\n \n}", cx);
let ix = buffer.len() - 2; let ix = buffer.len() - 2;
buffer.edit_with_autoindent([(ix..ix, "b\n.c")], size, cx); buffer.edit([(ix..ix, "b\n.c")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "fn a() {\n b\n .c\n}"); assert_eq!(buffer.text(), "fn a() {\n b\n .c\n}");
// indent further lines that continue the field expression, even after empty lines // indent further lines that continue the field expression, even after empty lines
let ix = buffer.len() - 2; let ix = buffer.len() - 2;
buffer.edit_with_autoindent([(ix..ix, "\n\n.d")], size, cx); buffer.edit([(ix..ix, "\n\n.d")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "fn a() {\n b\n .c\n \n .d\n}"); assert_eq!(buffer.text(), "fn a() {\n b\n .c\n \n .d\n}");
// dedent the line after the field expression // dedent the line after the field expression
let ix = buffer.len() - 2; let ix = buffer.len() - 2;
buffer.edit_with_autoindent([(ix..ix, ";\ne")], size, cx); buffer.edit([(ix..ix, ";\ne")], Some(AutoindentMode::EachLine), cx);
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
"fn a() {\n b\n .c\n \n .d;\n e\n}" "fn a() {\n b\n .c\n \n .d;\n e\n}"
@ -472,17 +475,17 @@ mod tests {
// indent inside a struct within a call // indent inside a struct within a call
buffer.set_text("const a: B = c(D {});", cx); buffer.set_text("const a: B = c(D {});", cx);
let ix = buffer.len() - 3; let ix = buffer.len() - 3;
buffer.edit_with_autoindent([(ix..ix, "\n\n")], size, cx); buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "const a: B = c(D {\n \n});"); assert_eq!(buffer.text(), "const a: B = c(D {\n \n});");
// indent further inside a nested call // indent further inside a nested call
let ix = buffer.len() - 4; let ix = buffer.len() - 4;
buffer.edit_with_autoindent([(ix..ix, "e: f(\n\n)")], size, cx); buffer.edit([(ix..ix, "e: f(\n\n)")], Some(AutoindentMode::EachLine), cx);
assert_eq!(buffer.text(), "const a: B = c(D {\n e: f(\n \n )\n});"); assert_eq!(buffer.text(), "const a: B = c(D {\n e: f(\n \n )\n});");
// keep that indent after an empty line // keep that indent after an empty line
let ix = buffer.len() - 8; let ix = buffer.len() - 8;
buffer.edit_with_autoindent([(ix..ix, "\n")], size, cx); buffer.edit([(ix..ix, "\n")], Some(AutoindentMode::EachLine), cx);
assert_eq!( assert_eq!(
buffer.text(), buffer.text(),
"const a: B = c(D {\n e: f(\n \n \n )\n});" "const a: B = c(D {\n e: f(\n \n \n )\n});"

2
crates/zed/src/zed.rs
View file

@ -453,7 +453,7 @@ fn open_log_file(
let buffer = project let buffer = project
.update(cx, |project, cx| project.create_buffer("", None, cx)) .update(cx, |project, cx| project.create_buffer("", None, cx))
.expect("creating buffers on a local workspace always succeeds"); .expect("creating buffers on a local workspace always succeeds");
buffer.update(cx, |buffer, cx| buffer.edit([(0..0, log)], cx)); buffer.update(cx, |buffer, cx| buffer.edit([(0..0, log)], None, cx));
let buffer = cx.add_model(|cx| { let buffer = cx.add_model(|cx| {
MultiBuffer::singleton(buffer, cx).with_title("Log".into()) MultiBuffer::singleton(buffer, cx).with_title("Log".into())