Merge pull request #205 from zed-industries/autoindent

Autoindent

Cargo.lock

@@ -759,6 +759,7 @@ dependencies = [
  "serde 1.0.125",
  "similar",
  "smallvec",
+ "smol",
  "sum_tree",
  "theme",
  "tree-sitter",

crates/buffer/Cargo.toml

@@ -22,6 +22,7 @@ seahash = "4.1"
 serde = { version = "1", features = ["derive"] }
 similar = "1.3"
 smallvec = { version = "1.6", features = ["union"] }
+smol = "1.2"
 tree-sitter = "0.19.5"
 
 [dev-dependencies]

crates/buffer/src/anchor.rs

@@ -1,3 +1,5 @@
+use crate::Point;
+
 use super::{Buffer, Content};
 use anyhow::Result;
 use std::{cmp::Ordering, ops::Range};
@@ -10,6 +12,24 @@ pub struct Anchor {
     pub version: clock::Global,
 }
 
+#[derive(Clone)]
+pub struct AnchorMap<T> {
+    pub(crate) version: clock::Global,
+    pub(crate) entries: Vec<((usize, Bias), T)>,
+}
+
+#[derive(Clone)]
+pub struct AnchorSet(pub(crate) AnchorMap<()>);
+
+#[derive(Clone)]
+pub struct AnchorRangeMap<T> {
+    pub(crate) version: clock::Global,
+    pub(crate) entries: Vec<(Range<(usize, Bias)>, T)>,
+}
+
+#[derive(Clone)]
+pub struct AnchorRangeSet(pub(crate) AnchorRangeMap<()>);
+
 impl Anchor {
     pub fn min() -> Self {
         Self {
@@ -62,6 +82,60 @@ impl Anchor {
     }
 }
 
+impl<T> AnchorMap<T> {
+    pub fn to_points<'a>(
+        &'a self,
+        content: impl Into<Content<'a>> + 'a,
+    ) -> impl Iterator<Item = (Point, &'a T)> + 'a {
+        let content = content.into();
+        content
+            .summaries_for_anchors(self)
+            .map(move |(sum, value)| (sum.lines, value))
+    }
+
+    pub fn version(&self) -> &clock::Global {
+        &self.version
+    }
+}
+
+impl AnchorSet {
+    pub fn to_points<'a>(
+        &'a self,
+        content: impl Into<Content<'a>> + 'a,
+    ) -> impl Iterator<Item = Point> + 'a {
+        self.0.to_points(content).map(move |(point, _)| point)
+    }
+}
+
+impl<T> AnchorRangeMap<T> {
+    pub fn to_point_ranges<'a>(
+        &'a self,
+        content: impl Into<Content<'a>> + 'a,
+    ) -> impl Iterator<Item = (Range<Point>, &'a T)> + 'a {
+        let content = content.into();
+        content
+            .summaries_for_anchor_ranges(self)
+            .map(move |(range, value)| ((range.start.lines..range.end.lines), value))
+    }
+
+    pub fn version(&self) -> &clock::Global {
+        &self.version
+    }
+}
+
+impl AnchorRangeSet {
+    pub fn to_point_ranges<'a>(
+        &'a self,
+        content: impl Into<Content<'a>> + 'a,
+    ) -> impl Iterator<Item = Range<Point>> + 'a {
+        self.0.to_point_ranges(content).map(|(range, _)| range)
+    }
+
+    pub fn version(&self) -> &clock::Global {
+        self.0.version()
+    }
+}
+
 pub trait AnchorRangeExt {
     fn cmp<'a>(&self, b: &Range<Anchor>, buffer: impl Into<Content<'a>>) -> Result<Ordering>;
 }

crates/buffer/src/language.rs

@@ -11,20 +11,23 @@ pub use tree_sitter::{Parser, Tree};
 pub struct LanguageConfig {
     pub name: String,
     pub path_suffixes: Vec<String>,
-    pub autoclose_pairs: Vec<AutoclosePair>,
+    pub brackets: Vec<BracketPair>,
 }
 
-#[derive(Clone, Deserialize)]
-pub struct AutoclosePair {
+#[derive(Clone, Debug, Deserialize)]
+pub struct BracketPair {
     pub start: String,
     pub end: String,
+    pub close: bool,
+    pub newline: bool,
 }
 
 pub struct Language {
     pub(crate) config: LanguageConfig,
     pub(crate) grammar: Grammar,
-    pub(crate) highlight_query: Query,
+    pub(crate) highlights_query: Query,
     pub(crate) brackets_query: Query,
+    pub(crate) indents_query: Query,
     pub(crate) highlight_map: Mutex<HighlightMap>,
 }
 
@@ -68,19 +71,25 @@ impl Language {
         Self {
             config,
             brackets_query: Query::new(grammar, "").unwrap(),
-            highlight_query: Query::new(grammar, "").unwrap(),
+            highlights_query: Query::new(grammar, "").unwrap(),
+            indents_query: Query::new(grammar, "").unwrap(),
             grammar,
             highlight_map: Default::default(),
         }
     }
 
-    pub fn with_highlights_query(mut self, highlights_query_source: &str) -> Result<Self> {
-        self.highlight_query = Query::new(self.grammar, highlights_query_source)?;
+    pub fn with_highlights_query(mut self, source: &str) -> Result<Self> {
+        self.highlights_query = Query::new(self.grammar, source)?;
         Ok(self)
     }
 
-    pub fn with_brackets_query(mut self, brackets_query_source: &str) -> Result<Self> {
-        self.brackets_query = Query::new(self.grammar, brackets_query_source)?;
+    pub fn with_brackets_query(mut self, source: &str) -> Result<Self> {
+        self.brackets_query = Query::new(self.grammar, source)?;
+        Ok(self)
+    }
+
+    pub fn with_indents_query(mut self, source: &str) -> Result<Self> {
+        self.indents_query = Query::new(self.grammar, source)?;
         Ok(self)
     }
 
@@ -88,8 +97,8 @@ impl Language {
         self.config.name.as_str()
     }
 
-    pub fn autoclose_pairs(&self) -> &[AutoclosePair] {
-        &self.config.autoclose_pairs
+    pub fn brackets(&self) -> &[BracketPair] {
+        &self.config.brackets
     }
 
     pub fn highlight_map(&self) -> HighlightMap {
@@ -97,7 +106,8 @@ impl Language {
     }
 
     pub fn set_theme(&self, theme: &SyntaxTheme) {
-        *self.highlight_map.lock() = HighlightMap::new(self.highlight_query.capture_names(), theme);
+        *self.highlight_map.lock() =
+            HighlightMap::new(self.highlights_query.capture_names(), theme);
     }
 }
 
@@ -110,28 +120,22 @@ mod tests {
         let grammar = tree_sitter_rust::language();
         let registry = LanguageRegistry {
             languages: vec![
-                Arc::new(Language {
-                    config: LanguageConfig {
+                Arc::new(Language::new(
+                    LanguageConfig {
                         name: "Rust".to_string(),
                         path_suffixes: vec!["rs".to_string()],
                         ..Default::default()
                     },
                     grammar,
-                    highlight_query: Query::new(grammar, "").unwrap(),
-                    brackets_query: Query::new(grammar, "").unwrap(),
-                    highlight_map: Default::default(),
-                }),
-                Arc::new(Language {
-                    config: LanguageConfig {
+                )),
+                Arc::new(Language::new(
+                    LanguageConfig {
                         name: "Make".to_string(),
                         path_suffixes: vec!["Makefile".to_string(), "mk".to_string()],
                         ..Default::default()
                     },
                     grammar,
-                    highlight_query: Query::new(grammar, "").unwrap(),
-                    brackets_query: Query::new(grammar, "").unwrap(),
-                    highlight_map: Default::default(),
-                }),
+                )),
             ],
         };
 

crates/buffer/src/rope.rs

@@ -115,6 +115,11 @@ impl Rope {
         self.chunks_in_range(start..self.len()).flat_map(str::chars)
     }
 
+    pub fn reversed_chars_at(&self, start: usize) -> impl Iterator<Item = char> + '_ {
+        self.reversed_chunks_in_range(0..start)
+            .flat_map(|chunk| chunk.chars().rev())
+    }
+
     pub fn bytes_at(&self, start: usize) -> impl Iterator<Item = u8> + '_ {
         self.chunks_in_range(start..self.len()).flat_map(str::bytes)
     }
@@ -123,8 +128,12 @@ impl Rope {
         self.chunks_in_range(0..self.len())
     }
 
-    pub fn chunks_in_range<'a>(&'a self, range: Range<usize>) -> Chunks<'a> {
-        Chunks::new(self, range)
+    pub fn chunks_in_range(&self, range: Range<usize>) -> Chunks {
+        Chunks::new(self, range, false)
+    }
+
+    pub fn reversed_chunks_in_range(&self, range: Range<usize>) -> Chunks {
+        Chunks::new(self, range, true)
     }
 
     pub fn to_point(&self, offset: usize) -> Point {
@@ -268,6 +277,7 @@ impl<'a> Cursor<'a> {
             }
         }
 
+        self.offset = end_offset;
         summary
     }
 
@@ -283,38 +293,65 @@ impl<'a> Cursor<'a> {
 pub struct Chunks<'a> {
     chunks: sum_tree::Cursor<'a, Chunk, usize>,
     range: Range<usize>,
+    reversed: bool,
 }
 
 impl<'a> Chunks<'a> {
-    pub fn new(rope: &'a Rope, range: Range<usize>) -> Self {
+    pub fn new(rope: &'a Rope, range: Range<usize>, reversed: bool) -> Self {
         let mut chunks = rope.chunks.cursor();
-        chunks.seek(&range.start, Bias::Right, &());
-        Self { chunks, range }
+        if reversed {
+            chunks.seek(&range.end, Bias::Left, &());
+        } else {
+            chunks.seek(&range.start, Bias::Right, &());
+        }
+        Self {
+            chunks,
+            range,
+            reversed,
+        }
     }
 
     pub fn offset(&self) -> usize {
-        self.range.start.max(*self.chunks.start())
+        if self.reversed {
+            self.range.end.min(self.chunks.end(&()))
+        } else {
+            self.range.start.max(*self.chunks.start())
+        }
     }
 
     pub fn seek(&mut self, offset: usize) {
-        if offset >= self.chunks.end(&()) {
-            self.chunks.seek_forward(&offset, Bias::Right, &());
+        let bias = if self.reversed {
+            Bias::Left
         } else {
-            self.chunks.seek(&offset, Bias::Right, &());
+            Bias::Right
+        };
+
+        if offset >= self.chunks.end(&()) {
+            self.chunks.seek_forward(&offset, bias, &());
+        } else {
+            self.chunks.seek(&offset, bias, &());
+        }
+
+        if self.reversed {
+            self.range.end = offset;
+        } else {
+            self.range.start = offset;
         }
-        self.range.start = offset;
     }
 
     pub fn peek(&self) -> Option<&'a str> {
-        if let Some(chunk) = self.chunks.item() {
-            let offset = *self.chunks.start();
-            if self.range.end > offset {
-                let start = self.range.start.saturating_sub(*self.chunks.start());
-                let end = self.range.end - self.chunks.start();
-                return Some(&chunk.0[start..chunk.0.len().min(end)]);
-            }
+        let chunk = self.chunks.item()?;
+        if self.reversed && self.range.start >= self.chunks.end(&()) {
+            return None;
         }
-        None
+        let chunk_start = *self.chunks.start();
+        if self.range.end <= chunk_start {
+            return None;
+        }
+
+        let start = self.range.start.saturating_sub(chunk_start);
+        let end = self.range.end - chunk_start;
+        Some(&chunk.0[start..chunk.0.len().min(end)])
     }
 }
 
@@ -324,7 +361,11 @@ impl<'a> Iterator for Chunks<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         let result = self.peek();
         if result.is_some() {
-            self.chunks.next(&());
+            if self.reversed {
+                self.chunks.prev(&());
+            } else {
+                self.chunks.next(&());
+            }
         }
         result
     }
@@ -570,6 +611,16 @@ mod tests {
                     actual.chunks_in_range(start_ix..end_ix).collect::<String>(),
                     &expected[start_ix..end_ix]
                 );
+
+                assert_eq!(
+                    actual
+                        .reversed_chunks_in_range(start_ix..end_ix)
+                        .collect::<Vec<&str>>()
+                        .into_iter()
+                        .rev()
+                        .collect::<String>(),
+                    &expected[start_ix..end_ix]
+                );
             }
 
             let mut point = Point::new(0, 0);

crates/buffer/src/tests.rs

@@ -0,0 +1,2 @@
+mod buffer;
+mod syntax;

crates/buffer/src/tests/buffer.rs

@@ -0,0 +1,790 @@
+use crate::*;
+use clock::ReplicaId;
+use rand::prelude::*;
+use std::{
+    cell::RefCell,
+    cmp::Ordering,
+    env,
+    iter::Iterator,
+    mem,
+    rc::Rc,
+    time::{Duration, Instant},
+};
+
+#[gpui::test]
+fn test_edit(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let mut buffer = Buffer::new(0, "abc", cx);
+        assert_eq!(buffer.text(), "abc");
+        buffer.edit(vec![3..3], "def", cx);
+        assert_eq!(buffer.text(), "abcdef");
+        buffer.edit(vec![0..0], "ghi", cx);
+        assert_eq!(buffer.text(), "ghiabcdef");
+        buffer.edit(vec![5..5], "jkl", cx);
+        assert_eq!(buffer.text(), "ghiabjklcdef");
+        buffer.edit(vec![6..7], "", cx);
+        assert_eq!(buffer.text(), "ghiabjlcdef");
+        buffer.edit(vec![4..9], "mno", cx);
+        assert_eq!(buffer.text(), "ghiamnoef");
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_edit_events(cx: &mut gpui::MutableAppContext) {
+    let mut now = Instant::now();
+    let buffer_1_events = Rc::new(RefCell::new(Vec::new()));
+    let buffer_2_events = Rc::new(RefCell::new(Vec::new()));
+
+    let buffer1 = cx.add_model(|cx| Buffer::new(0, "abcdef", cx));
+    let buffer2 = cx.add_model(|cx| Buffer::new(1, "abcdef", cx));
+    let buffer_ops = buffer1.update(cx, |buffer, cx| {
+        let buffer_1_events = buffer_1_events.clone();
+        cx.subscribe(&buffer1, move |_, _, event, _| {
+            buffer_1_events.borrow_mut().push(event.clone())
+        })
+        .detach();
+        let buffer_2_events = buffer_2_events.clone();
+        cx.subscribe(&buffer2, move |_, _, event, _| {
+            buffer_2_events.borrow_mut().push(event.clone())
+        })
+        .detach();
+
+        // An edit emits an edited event, followed by a dirtied event,
+        // since the buffer was previously in a clean state.
+        buffer.edit(Some(2..4), "XYZ", cx);
+
+        // An empty transaction does not emit any events.
+        buffer.start_transaction(None).unwrap();
+        buffer.end_transaction(None, cx).unwrap();
+
+        // A transaction containing two edits emits one edited event.
+        now += Duration::from_secs(1);
+        buffer.start_transaction_at(None, now).unwrap();
+        buffer.edit(Some(5..5), "u", cx);
+        buffer.edit(Some(6..6), "w", cx);
+        buffer.end_transaction_at(None, now, cx).unwrap();
+
+        // Undoing a transaction emits one edited event.
+        buffer.undo(cx);
+
+        buffer.operations.clone()
+    });
+
+    // Incorporating a set of remote ops emits a single edited event,
+    // followed by a dirtied event.
+    buffer2.update(cx, |buffer, cx| {
+        buffer.apply_ops(buffer_ops, cx).unwrap();
+    });
+
+    let buffer_1_events = buffer_1_events.borrow();
+    assert_eq!(
+        *buffer_1_events,
+        vec![Event::Edited, Event::Dirtied, Event::Edited, Event::Edited]
+    );
+
+    let buffer_2_events = buffer_2_events.borrow();
+    assert_eq!(*buffer_2_events, vec![Event::Edited, Event::Dirtied]);
+}
+
+#[gpui::test(iterations = 100)]
+fn test_random_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
+    let operations = env::var("OPERATIONS")
+        .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
+        .unwrap_or(10);
+
+    let reference_string_len = rng.gen_range(0..3);
+    let mut reference_string = RandomCharIter::new(&mut rng)
+        .take(reference_string_len)
+        .collect::<String>();
+    cx.add_model(|cx| {
+        let mut buffer = Buffer::new(0, reference_string.as_str(), cx);
+        buffer.history.group_interval = Duration::from_millis(rng.gen_range(0..=200));
+        let mut buffer_versions = Vec::new();
+        log::info!(
+            "buffer text {:?}, version: {:?}",
+            buffer.text(),
+            buffer.version()
+        );
+
+        for _i in 0..operations {
+            let (old_ranges, new_text) = buffer.randomly_mutate(&mut rng, cx);
+            for old_range in old_ranges.iter().rev() {
+                reference_string.replace_range(old_range.clone(), &new_text);
+            }
+            assert_eq!(buffer.text(), reference_string);
+            log::info!(
+                "buffer text {:?}, version: {:?}",
+                buffer.text(),
+                buffer.version()
+            );
+
+            if rng.gen_bool(0.25) {
+                buffer.randomly_undo_redo(&mut rng, cx);
+                reference_string = buffer.text();
+                log::info!(
+                    "buffer text {:?}, version: {:?}",
+                    buffer.text(),
+                    buffer.version()
+                );
+            }
+
+            let range = buffer.random_byte_range(0, &mut rng);
+            assert_eq!(
+                buffer.text_summary_for_range(range.clone()),
+                TextSummary::from(&reference_string[range])
+            );
+
+            if rng.gen_bool(0.3) {
+                buffer_versions.push(buffer.clone());
+            }
+        }
+
+        for mut old_buffer in buffer_versions {
+            let edits = buffer
+                .edits_since(old_buffer.version.clone())
+                .collect::<Vec<_>>();
+
+            log::info!(
+                "mutating old buffer version {:?}, text: {:?}, edits since: {:?}",
+                old_buffer.version(),
+                old_buffer.text(),
+                edits,
+            );
+
+            let mut delta = 0_isize;
+            for edit in edits {
+                let old_start = (edit.old_bytes.start as isize + delta) as usize;
+                let new_text: String = buffer.text_for_range(edit.new_bytes.clone()).collect();
+                old_buffer.edit(
+                    Some(old_start..old_start + edit.deleted_bytes()),
+                    new_text,
+                    cx,
+                );
+                delta += edit.delta();
+            }
+            assert_eq!(old_buffer.text(), buffer.text());
+        }
+
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_line_len(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let mut buffer = Buffer::new(0, "", cx);
+        buffer.edit(vec![0..0], "abcd\nefg\nhij", cx);
+        buffer.edit(vec![12..12], "kl\nmno", cx);
+        buffer.edit(vec![18..18], "\npqrs\n", cx);
+        buffer.edit(vec![18..21], "\nPQ", cx);
+
+        assert_eq!(buffer.line_len(0), 4);
+        assert_eq!(buffer.line_len(1), 3);
+        assert_eq!(buffer.line_len(2), 5);
+        assert_eq!(buffer.line_len(3), 3);
+        assert_eq!(buffer.line_len(4), 4);
+        assert_eq!(buffer.line_len(5), 0);
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_text_summary_for_range(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let buffer = Buffer::new(0, "ab\nefg\nhklm\nnopqrs\ntuvwxyz", cx);
+        assert_eq!(
+            buffer.text_summary_for_range(1..3),
+            TextSummary {
+                bytes: 2,
+                lines: Point::new(1, 0),
+                first_line_chars: 1,
+                last_line_chars: 0,
+                longest_row: 0,
+                longest_row_chars: 1,
+            }
+        );
+        assert_eq!(
+            buffer.text_summary_for_range(1..12),
+            TextSummary {
+                bytes: 11,
+                lines: Point::new(3, 0),
+                first_line_chars: 1,
+                last_line_chars: 0,
+                longest_row: 2,
+                longest_row_chars: 4,
+            }
+        );
+        assert_eq!(
+            buffer.text_summary_for_range(0..20),
+            TextSummary {
+                bytes: 20,
+                lines: Point::new(4, 1),
+                first_line_chars: 2,
+                last_line_chars: 1,
+                longest_row: 3,
+                longest_row_chars: 6,
+            }
+        );
+        assert_eq!(
+            buffer.text_summary_for_range(0..22),
+            TextSummary {
+                bytes: 22,
+                lines: Point::new(4, 3),
+                first_line_chars: 2,
+                last_line_chars: 3,
+                longest_row: 3,
+                longest_row_chars: 6,
+            }
+        );
+        assert_eq!(
+            buffer.text_summary_for_range(7..22),
+            TextSummary {
+                bytes: 15,
+                lines: Point::new(2, 3),
+                first_line_chars: 4,
+                last_line_chars: 3,
+                longest_row: 1,
+                longest_row_chars: 6,
+            }
+        );
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_chars_at(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let mut buffer = Buffer::new(0, "", cx);
+        buffer.edit(vec![0..0], "abcd\nefgh\nij", cx);
+        buffer.edit(vec![12..12], "kl\nmno", cx);
+        buffer.edit(vec![18..18], "\npqrs", cx);
+        buffer.edit(vec![18..21], "\nPQ", cx);
+
+        let chars = buffer.chars_at(Point::new(0, 0));
+        assert_eq!(chars.collect::<String>(), "abcd\nefgh\nijkl\nmno\nPQrs");
+
+        let chars = buffer.chars_at(Point::new(1, 0));
+        assert_eq!(chars.collect::<String>(), "efgh\nijkl\nmno\nPQrs");
+
+        let chars = buffer.chars_at(Point::new(2, 0));
+        assert_eq!(chars.collect::<String>(), "ijkl\nmno\nPQrs");
+
+        let chars = buffer.chars_at(Point::new(3, 0));
+        assert_eq!(chars.collect::<String>(), "mno\nPQrs");
+
+        let chars = buffer.chars_at(Point::new(4, 0));
+        assert_eq!(chars.collect::<String>(), "PQrs");
+
+        // Regression test:
+        let mut buffer = Buffer::new(0, "", cx);
+        buffer.edit(vec![0..0], "[workspace]\nmembers = [\n    \"xray_core\",\n    \"xray_server\",\n    \"xray_cli\",\n    \"xray_wasm\",\n]\n", cx);
+        buffer.edit(vec![60..60], "\n", cx);
+
+        let chars = buffer.chars_at(Point::new(6, 0));
+        assert_eq!(chars.collect::<String>(), "    \"xray_wasm\",\n]\n");
+
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_anchors(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let mut buffer = Buffer::new(0, "", cx);
+        buffer.edit(vec![0..0], "abc", cx);
+        let left_anchor = buffer.anchor_before(2);
+        let right_anchor = buffer.anchor_after(2);
+
+        buffer.edit(vec![1..1], "def\n", cx);
+        assert_eq!(buffer.text(), "adef\nbc");
+        assert_eq!(left_anchor.to_offset(&buffer), 6);
+        assert_eq!(right_anchor.to_offset(&buffer), 6);
+        assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
+        assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 });
+
+        buffer.edit(vec![2..3], "", cx);
+        assert_eq!(buffer.text(), "adf\nbc");
+        assert_eq!(left_anchor.to_offset(&buffer), 5);
+        assert_eq!(right_anchor.to_offset(&buffer), 5);
+        assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
+        assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 });
+
+        buffer.edit(vec![5..5], "ghi\n", cx);
+        assert_eq!(buffer.text(), "adf\nbghi\nc");
+        assert_eq!(left_anchor.to_offset(&buffer), 5);
+        assert_eq!(right_anchor.to_offset(&buffer), 9);
+        assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
+        assert_eq!(right_anchor.to_point(&buffer), Point { row: 2, column: 0 });
+
+        buffer.edit(vec![7..9], "", cx);
+        assert_eq!(buffer.text(), "adf\nbghc");
+        assert_eq!(left_anchor.to_offset(&buffer), 5);
+        assert_eq!(right_anchor.to_offset(&buffer), 7);
+        assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 },);
+        assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 3 });
+
+        // Ensure anchoring to a point is equivalent to anchoring to an offset.
+        assert_eq!(
+            buffer.anchor_before(Point { row: 0, column: 0 }),
+            buffer.anchor_before(0)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 0, column: 1 }),
+            buffer.anchor_before(1)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 0, column: 2 }),
+            buffer.anchor_before(2)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 0, column: 3 }),
+            buffer.anchor_before(3)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 1, column: 0 }),
+            buffer.anchor_before(4)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 1, column: 1 }),
+            buffer.anchor_before(5)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 1, column: 2 }),
+            buffer.anchor_before(6)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 1, column: 3 }),
+            buffer.anchor_before(7)
+        );
+        assert_eq!(
+            buffer.anchor_before(Point { row: 1, column: 4 }),
+            buffer.anchor_before(8)
+        );
+
+        // Comparison between anchors.
+        let anchor_at_offset_0 = buffer.anchor_before(0);
+        let anchor_at_offset_1 = buffer.anchor_before(1);
+        let anchor_at_offset_2 = buffer.anchor_before(2);
+
+        assert_eq!(
+            anchor_at_offset_0
+                .cmp(&anchor_at_offset_0, &buffer)
+                .unwrap(),
+            Ordering::Equal
+        );
+        assert_eq!(
+            anchor_at_offset_1
+                .cmp(&anchor_at_offset_1, &buffer)
+                .unwrap(),
+            Ordering::Equal
+        );
+        assert_eq!(
+            anchor_at_offset_2
+                .cmp(&anchor_at_offset_2, &buffer)
+                .unwrap(),
+            Ordering::Equal
+        );
+
+        assert_eq!(
+            anchor_at_offset_0
+                .cmp(&anchor_at_offset_1, &buffer)
+                .unwrap(),
+            Ordering::Less
+        );
+        assert_eq!(
+            anchor_at_offset_1
+                .cmp(&anchor_at_offset_2, &buffer)
+                .unwrap(),
+            Ordering::Less
+        );
+        assert_eq!(
+            anchor_at_offset_0
+                .cmp(&anchor_at_offset_2, &buffer)
+                .unwrap(),
+            Ordering::Less
+        );
+
+        assert_eq!(
+            anchor_at_offset_1
+                .cmp(&anchor_at_offset_0, &buffer)
+                .unwrap(),
+            Ordering::Greater
+        );
+        assert_eq!(
+            anchor_at_offset_2
+                .cmp(&anchor_at_offset_1, &buffer)
+                .unwrap(),
+            Ordering::Greater
+        );
+        assert_eq!(
+            anchor_at_offset_2
+                .cmp(&anchor_at_offset_0, &buffer)
+                .unwrap(),
+            Ordering::Greater
+        );
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_anchors_at_start_and_end(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let mut buffer = Buffer::new(0, "", cx);
+        let before_start_anchor = buffer.anchor_before(0);
+        let after_end_anchor = buffer.anchor_after(0);
+
+        buffer.edit(vec![0..0], "abc", cx);
+        assert_eq!(buffer.text(), "abc");
+        assert_eq!(before_start_anchor.to_offset(&buffer), 0);
+        assert_eq!(after_end_anchor.to_offset(&buffer), 3);
+
+        let after_start_anchor = buffer.anchor_after(0);
+        let before_end_anchor = buffer.anchor_before(3);
+
+        buffer.edit(vec![3..3], "def", cx);
+        buffer.edit(vec![0..0], "ghi", cx);
+        assert_eq!(buffer.text(), "ghiabcdef");
+        assert_eq!(before_start_anchor.to_offset(&buffer), 0);
+        assert_eq!(after_start_anchor.to_offset(&buffer), 3);
+        assert_eq!(before_end_anchor.to_offset(&buffer), 6);
+        assert_eq!(after_end_anchor.to_offset(&buffer), 9);
+        buffer
+    });
+}
+
+#[gpui::test]
+async fn test_apply_diff(mut cx: gpui::TestAppContext) {
+    let text = "a\nbb\nccc\ndddd\neeeee\nffffff\n";
+    let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
+
+    let text = "a\nccc\ndddd\nffffff\n";
+    let diff = buffer.read_with(&cx, |b, cx| b.diff(text.into(), cx)).await;
+    buffer.update(&mut cx, |b, cx| b.apply_diff(diff, cx));
+    cx.read(|cx| assert_eq!(buffer.read(cx).text(), text));
+
+    let text = "a\n1\n\nccc\ndd2dd\nffffff\n";
+    let diff = buffer.read_with(&cx, |b, cx| b.diff(text.into(), cx)).await;
+    buffer.update(&mut cx, |b, cx| b.apply_diff(diff, cx));
+    cx.read(|cx| assert_eq!(buffer.read(cx).text(), text));
+}
+
+#[gpui::test]
+fn test_undo_redo(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let mut buffer = Buffer::new(0, "1234", cx);
+        // Set group interval to zero so as to not group edits in the undo stack.
+        buffer.history.group_interval = Duration::from_secs(0);
+
+        buffer.edit(vec![1..1], "abx", cx);
+        buffer.edit(vec![3..4], "yzef", cx);
+        buffer.edit(vec![3..5], "cd", cx);
+        assert_eq!(buffer.text(), "1abcdef234");
+
+        let transactions = buffer.history.undo_stack.clone();
+        assert_eq!(transactions.len(), 3);
+
+        buffer.undo_or_redo(transactions[0].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1cdef234");
+        buffer.undo_or_redo(transactions[0].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1abcdef234");
+
+        buffer.undo_or_redo(transactions[1].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1abcdx234");
+        buffer.undo_or_redo(transactions[2].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1abx234");
+        buffer.undo_or_redo(transactions[1].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1abyzef234");
+        buffer.undo_or_redo(transactions[2].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1abcdef234");
+
+        buffer.undo_or_redo(transactions[2].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1abyzef234");
+        buffer.undo_or_redo(transactions[0].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1yzef234");
+        buffer.undo_or_redo(transactions[1].clone(), cx).unwrap();
+        assert_eq!(buffer.text(), "1234");
+
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_history(cx: &mut gpui::MutableAppContext) {
+    cx.add_model(|cx| {
+        let mut now = Instant::now();
+        let mut buffer = Buffer::new(0, "123456", cx);
+
+        let set_id =
+            buffer.add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap(), cx);
+        buffer.start_transaction_at(Some(set_id), now).unwrap();
+        buffer.edit(vec![2..4], "cd", cx);
+        buffer.end_transaction_at(Some(set_id), now, cx).unwrap();
+        assert_eq!(buffer.text(), "12cd56");
+        assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
+
+        buffer.start_transaction_at(Some(set_id), now).unwrap();
+        buffer
+            .update_selection_set(
+                set_id,
+                buffer.selections_from_ranges(vec![1..3]).unwrap(),
+                cx,
+            )
+            .unwrap();
+        buffer.edit(vec![4..5], "e", cx);
+        buffer.end_transaction_at(Some(set_id), now, cx).unwrap();
+        assert_eq!(buffer.text(), "12cde6");
+        assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
+
+        now += buffer.history.group_interval + Duration::from_millis(1);
+        buffer.start_transaction_at(Some(set_id), now).unwrap();
+        buffer
+            .update_selection_set(
+                set_id,
+                buffer.selections_from_ranges(vec![2..2]).unwrap(),
+                cx,
+            )
+            .unwrap();
+        buffer.edit(vec![0..1], "a", cx);
+        buffer.edit(vec![1..1], "b", cx);
+        buffer.end_transaction_at(Some(set_id), now, cx).unwrap();
+        assert_eq!(buffer.text(), "ab2cde6");
+        assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
+
+        // Last transaction happened past the group interval, undo it on its
+        // own.
+        buffer.undo(cx);
+        assert_eq!(buffer.text(), "12cde6");
+        assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
+
+        // First two transactions happened within the group interval, undo them
+        // together.
+        buffer.undo(cx);
+        assert_eq!(buffer.text(), "123456");
+        assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
+
+        // Redo the first two transactions together.
+        buffer.redo(cx);
+        assert_eq!(buffer.text(), "12cde6");
+        assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
+
+        // Redo the last transaction on its own.
+        buffer.redo(cx);
+        assert_eq!(buffer.text(), "ab2cde6");
+        assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
+
+        buffer.start_transaction_at(None, now).unwrap();
+        buffer.end_transaction_at(None, now, cx).unwrap();
+        buffer.undo(cx);
+        assert_eq!(buffer.text(), "12cde6");
+
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_concurrent_edits(cx: &mut gpui::MutableAppContext) {
+    let text = "abcdef";
+
+    let buffer1 = cx.add_model(|cx| Buffer::new(1, text, cx));
+    let buffer2 = cx.add_model(|cx| Buffer::new(2, text, cx));
+    let buffer3 = cx.add_model(|cx| Buffer::new(3, text, cx));
+
+    let buf1_op = buffer1.update(cx, |buffer, cx| {
+        buffer.edit(vec![1..2], "12", cx);
+        assert_eq!(buffer.text(), "a12cdef");
+        buffer.operations.last().unwrap().clone()
+    });
+    let buf2_op = buffer2.update(cx, |buffer, cx| {
+        buffer.edit(vec![3..4], "34", cx);
+        assert_eq!(buffer.text(), "abc34ef");
+        buffer.operations.last().unwrap().clone()
+    });
+    let buf3_op = buffer3.update(cx, |buffer, cx| {
+        buffer.edit(vec![5..6], "56", cx);
+        assert_eq!(buffer.text(), "abcde56");
+        buffer.operations.last().unwrap().clone()
+    });
+
+    buffer1.update(cx, |buffer, _| {
+        buffer.apply_op(buf2_op.clone()).unwrap();
+        buffer.apply_op(buf3_op.clone()).unwrap();
+    });
+    buffer2.update(cx, |buffer, _| {
+        buffer.apply_op(buf1_op.clone()).unwrap();
+        buffer.apply_op(buf3_op.clone()).unwrap();
+    });
+    buffer3.update(cx, |buffer, _| {
+        buffer.apply_op(buf1_op.clone()).unwrap();
+        buffer.apply_op(buf2_op.clone()).unwrap();
+    });
+
+    assert_eq!(buffer1.read(cx).text(), "a12c34e56");
+    assert_eq!(buffer2.read(cx).text(), "a12c34e56");
+    assert_eq!(buffer3.read(cx).text(), "a12c34e56");
+}
+
+#[gpui::test(iterations = 100)]
+fn test_random_concurrent_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
+    let peers = env::var("PEERS")
+        .map(|i| i.parse().expect("invalid `PEERS` variable"))
+        .unwrap_or(5);
+    let operations = env::var("OPERATIONS")
+        .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
+        .unwrap_or(10);
+
+    let base_text_len = rng.gen_range(0..10);
+    let base_text = RandomCharIter::new(&mut rng)
+        .take(base_text_len)
+        .collect::<String>();
+    let mut replica_ids = Vec::new();
+    let mut buffers = Vec::new();
+    let mut network = Network::new(rng.clone());
+
+    for i in 0..peers {
+        let buffer = cx.add_model(|cx| {
+            let mut buf = Buffer::new(i as ReplicaId, base_text.as_str(), cx);
+            buf.history.group_interval = Duration::from_millis(rng.gen_range(0..=200));
+            buf
+        });
+        buffers.push(buffer);
+        replica_ids.push(i as u16);
+        network.add_peer(i as u16);
+    }
+
+    log::info!("initial text: {:?}", base_text);
+
+    let mut mutation_count = operations;
+    loop {
+        let replica_index = rng.gen_range(0..peers);
+        let replica_id = replica_ids[replica_index];
+        buffers[replica_index].update(cx, |buffer, cx| match rng.gen_range(0..=100) {
+            0..=50 if mutation_count != 0 => {
+                buffer.randomly_mutate(&mut rng, cx);
+                network.broadcast(buffer.replica_id, mem::take(&mut buffer.operations));
+                log::info!("buffer {} text: {:?}", buffer.replica_id, buffer.text());
+                mutation_count -= 1;
+            }
+            51..=70 if mutation_count != 0 => {
+                buffer.randomly_undo_redo(&mut rng, cx);
+                network.broadcast(buffer.replica_id, mem::take(&mut buffer.operations));
+                mutation_count -= 1;
+            }
+            71..=100 if network.has_unreceived(replica_id) => {
+                let ops = network.receive(replica_id);
+                if !ops.is_empty() {
+                    log::info!(
+                        "peer {} applying {} ops from the network.",
+                        replica_id,
+                        ops.len()
+                    );
+                    buffer.apply_ops(ops, cx).unwrap();
+                }
+            }
+            _ => {}
+        });
+
+        if mutation_count == 0 && network.is_idle() {
+            break;
+        }
+    }
+
+    let first_buffer = buffers[0].read(cx);
+    for buffer in &buffers[1..] {
+        let buffer = buffer.read(cx);
+        assert_eq!(
+            buffer.text(),
+            first_buffer.text(),
+            "Replica {} text != Replica 0 text",
+            buffer.replica_id
+        );
+        assert_eq!(
+            buffer.selection_sets().collect::<HashMap<_, _>>(),
+            first_buffer.selection_sets().collect::<HashMap<_, _>>()
+        );
+        assert_eq!(
+            buffer.all_selection_ranges().collect::<HashMap<_, _>>(),
+            first_buffer
+                .all_selection_ranges()
+                .collect::<HashMap<_, _>>()
+        );
+    }
+}
+
+#[derive(Clone)]
+struct Envelope<T: Clone> {
+    message: T,
+    sender: ReplicaId,
+}
+
+struct Network<T: Clone, R: rand::Rng> {
+    inboxes: std::collections::BTreeMap<ReplicaId, Vec<Envelope<T>>>,
+    all_messages: Vec<T>,
+    rng: R,
+}
+
+impl<T: Clone, R: rand::Rng> Network<T, R> {
+    fn new(rng: R) -> Self {
+        Network {
+            inboxes: Default::default(),
+            all_messages: Vec::new(),
+            rng,
+        }
+    }
+
+    fn add_peer(&mut self, id: ReplicaId) {
+        self.inboxes.insert(id, Vec::new());
+    }
+
+    fn is_idle(&self) -> bool {
+        self.inboxes.values().all(|i| i.is_empty())
+    }
+
+    fn broadcast(&mut self, sender: ReplicaId, messages: Vec<T>) {
+        for (replica, inbox) in self.inboxes.iter_mut() {
+            if *replica != sender {
+                for message in &messages {
+                    let min_index = inbox
+                        .iter()
+                        .enumerate()
+                        .rev()
+                        .find_map(|(index, envelope)| {
+                            if sender == envelope.sender {
+                                Some(index + 1)
+                            } else {
+                                None
+                            }
+                        })
+                        .unwrap_or(0);
+
+                    // Insert one or more duplicates of this message *after* the previous
+                    // message delivered by this replica.
+                    for _ in 0..self.rng.gen_range(1..4) {
+                        let insertion_index = self.rng.gen_range(min_index..inbox.len() + 1);
+                        inbox.insert(
+                            insertion_index,
+                            Envelope {
+                                message: message.clone(),
+                                sender,
+                            },
+                        );
+                    }
+                }
+            }
+        }
+        self.all_messages.extend(messages);
+    }
+
+    fn has_unreceived(&self, receiver: ReplicaId) -> bool {
+        !self.inboxes[&receiver].is_empty()
+    }
+
+    fn receive(&mut self, receiver: ReplicaId) -> Vec<T> {
+        let inbox = self.inboxes.get_mut(&receiver).unwrap();
+        let count = self.rng.gen_range(0..inbox.len() + 1);
+        inbox
+            .drain(0..count)
+            .map(|envelope| envelope.message)
+            .collect()
+    }
+}

crates/buffer/src/tests/syntax.rs

@@ -0,0 +1,380 @@
+use crate::*;
+use gpui::{ModelHandle, MutableAppContext};
+use unindent::Unindent as _;
+
+#[gpui::test]
+async fn test_reparse(mut cx: gpui::TestAppContext) {
+    let buffer = cx.add_model(|cx| {
+        let text = "fn a() {}".into();
+        Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx)
+    });
+
+    // Wait for the initial text to parse
+    buffer
+        .condition(&cx, |buffer, _| !buffer.is_parsing())
+        .await;
+    assert_eq!(
+        get_tree_sexp(&buffer, &cx),
+        concat!(
+            "(source_file (function_item name: (identifier) ",
+            "parameters: (parameters) ",
+            "body: (block)))"
+        )
+    );
+
+    buffer.update(&mut cx, |buffer, _| {
+        buffer.set_sync_parse_timeout(Duration::ZERO)
+    });
+
+    // Perform some edits (add parameter and variable reference)
+    // Parsing doesn't begin until the transaction is complete
+    buffer.update(&mut cx, |buf, cx| {
+        buf.start_transaction(None).unwrap();
+
+        let offset = buf.text().find(")").unwrap();
+        buf.edit(vec![offset..offset], "b: C", cx);
+        assert!(!buf.is_parsing());
+
+        let offset = buf.text().find("}").unwrap();
+        buf.edit(vec![offset..offset], " d; ", cx);
+        assert!(!buf.is_parsing());
+
+        buf.end_transaction(None, cx).unwrap();
+        assert_eq!(buf.text(), "fn a(b: C) { d; }");
+        assert!(buf.is_parsing());
+    });
+    buffer
+        .condition(&cx, |buffer, _| !buffer.is_parsing())
+        .await;
+    assert_eq!(
+        get_tree_sexp(&buffer, &cx),
+        concat!(
+            "(source_file (function_item name: (identifier) ",
+            "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
+            "body: (block (identifier))))"
+        )
+    );
+
+    // Perform a series of edits without waiting for the current parse to complete:
+    // * turn identifier into a field expression
+    // * turn field expression into a method call
+    // * add a turbofish to the method call
+    buffer.update(&mut cx, |buf, cx| {
+        let offset = buf.text().find(";").unwrap();
+        buf.edit(vec![offset..offset], ".e", cx);
+        assert_eq!(buf.text(), "fn a(b: C) { d.e; }");
+        assert!(buf.is_parsing());
+    });
+    buffer.update(&mut cx, |buf, cx| {
+        let offset = buf.text().find(";").unwrap();
+        buf.edit(vec![offset..offset], "(f)", cx);
+        assert_eq!(buf.text(), "fn a(b: C) { d.e(f); }");
+        assert!(buf.is_parsing());
+    });
+    buffer.update(&mut cx, |buf, cx| {
+        let offset = buf.text().find("(f)").unwrap();
+        buf.edit(vec![offset..offset], "::<G>", cx);
+        assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
+        assert!(buf.is_parsing());
+    });
+    buffer
+        .condition(&cx, |buffer, _| !buffer.is_parsing())
+        .await;
+    assert_eq!(
+        get_tree_sexp(&buffer, &cx),
+        concat!(
+            "(source_file (function_item name: (identifier) ",
+            "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
+            "body: (block (call_expression ",
+            "function: (generic_function ",
+            "function: (field_expression value: (identifier) field: (field_identifier)) ",
+            "type_arguments: (type_arguments (type_identifier))) ",
+            "arguments: (arguments (identifier))))))",
+        )
+    );
+
+    buffer.update(&mut cx, |buf, cx| {
+        buf.undo(cx);
+        assert_eq!(buf.text(), "fn a() {}");
+        assert!(buf.is_parsing());
+    });
+    buffer
+        .condition(&cx, |buffer, _| !buffer.is_parsing())
+        .await;
+    assert_eq!(
+        get_tree_sexp(&buffer, &cx),
+        concat!(
+            "(source_file (function_item name: (identifier) ",
+            "parameters: (parameters) ",
+            "body: (block)))"
+        )
+    );
+
+    buffer.update(&mut cx, |buf, cx| {
+        buf.redo(cx);
+        assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
+        assert!(buf.is_parsing());
+    });
+    buffer
+        .condition(&cx, |buffer, _| !buffer.is_parsing())
+        .await;
+    assert_eq!(
+        get_tree_sexp(&buffer, &cx),
+        concat!(
+            "(source_file (function_item name: (identifier) ",
+            "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
+            "body: (block (call_expression ",
+            "function: (generic_function ",
+            "function: (field_expression value: (identifier) field: (field_identifier)) ",
+            "type_arguments: (type_arguments (type_identifier))) ",
+            "arguments: (arguments (identifier))))))",
+        )
+    );
+
+    fn get_tree_sexp(buffer: &ModelHandle<Buffer>, cx: &gpui::TestAppContext) -> String {
+        buffer.read_with(cx, |buffer, _| {
+            buffer.syntax_tree().unwrap().root_node().to_sexp()
+        })
+    }
+}
+
+#[gpui::test]
+fn test_enclosing_bracket_ranges(cx: &mut MutableAppContext) {
+    let buffer = cx.add_model(|cx| {
+        let text = "
+            mod x {
+                mod y {
+
+                }
+            }
+        "
+        .unindent()
+        .into();
+        Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx)
+    });
+    let buffer = buffer.read(cx);
+    assert_eq!(
+        buffer.enclosing_bracket_point_ranges(Point::new(1, 6)..Point::new(1, 6)),
+        Some((
+            Point::new(0, 6)..Point::new(0, 7),
+            Point::new(4, 0)..Point::new(4, 1)
+        ))
+    );
+    assert_eq!(
+        buffer.enclosing_bracket_point_ranges(Point::new(1, 10)..Point::new(1, 10)),
+        Some((
+            Point::new(1, 10)..Point::new(1, 11),
+            Point::new(3, 4)..Point::new(3, 5)
+        ))
+    );
+    assert_eq!(
+        buffer.enclosing_bracket_point_ranges(Point::new(3, 5)..Point::new(3, 5)),
+        Some((
+            Point::new(1, 10)..Point::new(1, 11),
+            Point::new(3, 4)..Point::new(3, 5)
+        ))
+    );
+}
+
+#[gpui::test]
+fn test_edit_with_autoindent(cx: &mut MutableAppContext) {
+    cx.add_model(|cx| {
+        let text = "fn a() {}".into();
+        let mut buffer = Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx);
+
+        buffer.edit_with_autoindent([8..8], "\n\n", cx);
+        assert_eq!(buffer.text(), "fn a() {\n    \n}");
+
+        buffer.edit_with_autoindent([Point::new(1, 4)..Point::new(1, 4)], "b()\n", cx);
+        assert_eq!(buffer.text(), "fn a() {\n    b()\n    \n}");
+
+        buffer.edit_with_autoindent([Point::new(2, 4)..Point::new(2, 4)], ".c", cx);
+        assert_eq!(buffer.text(), "fn a() {\n    b()\n        .c\n}");
+
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_autoindent_moves_selections(cx: &mut MutableAppContext) {
+    cx.add_model(|cx| {
+        let text = History::new("fn a() {}".into());
+        let mut buffer = Buffer::from_history(0, text, None, Some(rust_lang()), cx);
+
+        let selection_set_id = buffer.add_selection_set(Vec::new(), cx);
+        buffer.start_transaction(Some(selection_set_id)).unwrap();
+        buffer.edit_with_autoindent([5..5, 9..9], "\n\n", cx);
+        buffer
+            .update_selection_set(
+                selection_set_id,
+                vec![
+                    Selection {
+                        id: 0,
+                        start: buffer.anchor_before(Point::new(1, 0)),
+                        end: buffer.anchor_before(Point::new(1, 0)),
+                        reversed: false,
+                        goal: SelectionGoal::None,
+                    },
+                    Selection {
+                        id: 1,
+                        start: buffer.anchor_before(Point::new(4, 0)),
+                        end: buffer.anchor_before(Point::new(4, 0)),
+                        reversed: false,
+                        goal: SelectionGoal::None,
+                    },
+                ],
+                cx,
+            )
+            .unwrap();
+        assert_eq!(buffer.text(), "fn a(\n\n) {}\n\n");
+
+        // Ending the transaction runs the auto-indent. The selection
+        // at the start of the auto-indented row is pushed to the right.
+        buffer.end_transaction(Some(selection_set_id), cx).unwrap();
+        assert_eq!(buffer.text(), "fn a(\n    \n) {}\n\n");
+        let selection_ranges = buffer
+            .selection_set(selection_set_id)
+            .unwrap()
+            .selections
+            .iter()
+            .map(|selection| selection.point_range(&buffer))
+            .collect::<Vec<_>>();
+
+        assert_eq!(selection_ranges[0], empty(Point::new(1, 4)));
+        assert_eq!(selection_ranges[1], empty(Point::new(4, 0)));
+
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut MutableAppContext) {
+    cx.add_model(|cx| {
+        let text = "
+            fn a() {
+            c;
+            d;
+            }
+        "
+        .unindent()
+        .into();
+        let mut buffer = Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx);
+
+        // Lines 2 and 3 don't match the indentation suggestion. When editing these lines,
+        // their indentation is not adjusted.
+        buffer.edit_with_autoindent([empty(Point::new(1, 1)), empty(Point::new(2, 1))], "()", cx);
+        assert_eq!(
+            buffer.text(),
+            "
+            fn a() {
+            c();
+            d();
+            }
+            "
+            .unindent()
+        );
+
+        // When appending new content after these lines, the indentation is based on the
+        // preceding lines' actual indentation.
+        buffer.edit_with_autoindent(
+            [empty(Point::new(1, 1)), empty(Point::new(2, 1))],
+            "\n.f\n.g",
+            cx,
+        );
+        assert_eq!(
+            buffer.text(),
+            "
+            fn a() {
+            c
+                .f
+                .g();
+            d
+                .f
+                .g();
+            }
+            "
+            .unindent()
+        );
+        buffer
+    });
+}
+
+#[gpui::test]
+fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppContext) {
+    cx.add_model(|cx| {
+        let text = History::new(
+            "
+                fn a() {}
+            "
+            .unindent()
+            .into(),
+        );
+        let mut buffer = Buffer::from_history(0, text, None, Some(rust_lang()), cx);
+
+        buffer.edit_with_autoindent([5..5], "\nb", cx);
+        assert_eq!(
+            buffer.text(),
+            "
+                fn a(
+                    b) {}
+            "
+            .unindent()
+        );
+
+        // The indentation suggestion changed because `@end` node (a close paren)
+        // is now at the beginning of the line.
+        buffer.edit_with_autoindent([Point::new(1, 4)..Point::new(1, 5)], "", cx);
+        assert_eq!(
+            buffer.text(),
+            "
+                fn a(
+                ) {}
+            "
+            .unindent()
+        );
+
+        buffer
+    });
+}
+
+#[test]
+fn test_contiguous_ranges() {
+    assert_eq!(
+        contiguous_ranges([1, 2, 3, 5, 6, 9, 10, 11, 12], 100).collect::<Vec<_>>(),
+        &[1..4, 5..7, 9..13]
+    );
+
+    // Respects the `max_len` parameter
+    assert_eq!(
+        contiguous_ranges([2, 3, 4, 5, 6, 7, 8, 9, 23, 24, 25, 26, 30, 31], 3).collect::<Vec<_>>(),
+        &[2..5, 5..8, 8..10, 23..26, 26..27, 30..32],
+    );
+}
+
+fn rust_lang() -> Arc<Language> {
+    Arc::new(
+        Language::new(
+            LanguageConfig {
+                name: "Rust".to_string(),
+                path_suffixes: vec!["rs".to_string()],
+                ..Default::default()
+            },
+            tree_sitter_rust::language(),
+        )
+        .with_indents_query(
+            r#"
+                (call_expression) @indent
+                (field_expression) @indent
+                (_ "(" ")" @end) @indent
+                (_ "{" "}" @end) @indent
+            "#,
+        )
+        .unwrap()
+        .with_brackets_query(r#" ("{" @open "}" @close) "#)
+        .unwrap(),
+    )
+}
+
+fn empty(point: Point) -> Range<Point> {
+    point..point
+}

crates/editor/src/lib.rs

@@ -21,7 +21,7 @@ use smol::Timer;
 use std::{
     cell::RefCell,
     cmp::{self, Ordering},
-    mem,
+    iter, mem,
     ops::{Range, RangeInclusive},
     rc::Rc,
     sync::Arc,
@@ -38,6 +38,8 @@ action!(Cancel);
 action!(Backspace);
 action!(Delete);
 action!(Input, String);
+action!(Newline);
+action!(Tab);
 action!(DeleteLine);
 action!(DeleteToPreviousWordBoundary);
 action!(DeleteToNextWordBoundary);
@@ -95,13 +97,13 @@ pub fn init(cx: &mut MutableAppContext) {
         Binding::new("ctrl-h", Backspace, Some("Editor")),
         Binding::new("delete", Delete, Some("Editor")),
         Binding::new("ctrl-d", Delete, Some("Editor")),
-        Binding::new("enter", Input("\n".into()), Some("Editor && mode == full")),
+        Binding::new("enter", Newline, Some("Editor && mode == full")),
         Binding::new(
             "alt-enter",
             Input("\n".into()),
             Some("Editor && mode == auto_height"),
         ),
-        Binding::new("tab", Input("\t".into()), Some("Editor")),
+        Binding::new("tab", Tab, Some("Editor")),
         Binding::new("ctrl-shift-K", DeleteLine, Some("Editor")),
         Binding::new(
             "alt-backspace",
@@ -193,8 +195,10 @@ pub fn init(cx: &mut MutableAppContext) {
     cx.add_action(Editor::select);
     cx.add_action(Editor::cancel);
     cx.add_action(Editor::handle_input);
+    cx.add_action(Editor::newline);
     cx.add_action(Editor::backspace);
     cx.add_action(Editor::delete);
+    cx.add_action(Editor::tab);
     cx.add_action(Editor::delete_line);
     cx.add_action(Editor::delete_to_previous_word_boundary);
     cx.add_action(Editor::delete_to_next_word_boundary);
@@ -292,7 +296,7 @@ pub struct Editor {
     pending_selection: Option<Selection>,
     next_selection_id: usize,
     add_selections_state: Option<AddSelectionsState>,
-    autoclose_stack: Vec<AutoclosePairState>,
+    autoclose_stack: Vec<BracketPairState>,
     select_larger_syntax_node_stack: Vec<Arc<[Selection]>>,
     scroll_position: Vector2F,
     scroll_top_anchor: Anchor,
@@ -320,9 +324,9 @@ struct AddSelectionsState {
     stack: Vec<usize>,
 }
 
-struct AutoclosePairState {
+struct BracketPairState {
     ranges: SmallVec<[Range<Anchor>; 32]>,
-    pair: AutoclosePair,
+    pair: BracketPair,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -750,6 +754,130 @@ impl Editor {
         }
     }
 
+    pub fn newline(&mut self, _: &Newline, cx: &mut ViewContext<Self>) {
+        self.start_transaction(cx);
+        let mut old_selections = SmallVec::<[_; 32]>::new();
+        {
+            let selections = self.selections(cx);
+            let buffer = self.buffer.read(cx);
+            for selection in selections.iter() {
+                let start_point = selection.start.to_point(buffer);
+                let indent = buffer
+                    .indent_column_for_line(start_point.row)
+                    .min(start_point.column);
+                let start = selection.start.to_offset(buffer);
+                let end = selection.end.to_offset(buffer);
+
+                let mut insert_extra_newline = false;
+                if let Some(language) = buffer.language() {
+                    let leading_whitespace_len = buffer
+                        .reversed_chars_at(start)
+                        .take_while(|c| c.is_whitespace() && *c != '\n')
+                        .map(|c| c.len_utf8())
+                        .sum::<usize>();
+
+                    let trailing_whitespace_len = buffer
+                        .chars_at(end)
+                        .take_while(|c| c.is_whitespace() && *c != '\n')
+                        .map(|c| c.len_utf8())
+                        .sum::<usize>();
+
+                    insert_extra_newline = language.brackets().iter().any(|pair| {
+                        let pair_start = pair.start.trim_end();
+                        let pair_end = pair.end.trim_start();
+
+                        pair.newline
+                            && buffer.contains_str_at(end + trailing_whitespace_len, pair_end)
+                            && buffer.contains_str_at(
+                                (start - leading_whitespace_len).saturating_sub(pair_start.len()),
+                                pair_start,
+                            )
+                    });
+                }
+
+                old_selections.push((selection.id, start..end, indent, insert_extra_newline));
+            }
+        }
+
+        let mut new_selections = Vec::with_capacity(old_selections.len());
+        self.buffer.update(cx, |buffer, cx| {
+            let mut delta = 0_isize;
+            let mut pending_edit: Option<PendingEdit> = None;
+            for (_, range, indent, insert_extra_newline) in &old_selections {
+                if pending_edit.as_ref().map_or(false, |pending| {
+                    pending.indent != *indent
+                        || pending.insert_extra_newline != *insert_extra_newline
+                }) {
+                    let pending = pending_edit.take().unwrap();
+                    let mut new_text = String::with_capacity(1 + pending.indent as usize);
+                    new_text.push('\n');
+                    new_text.extend(iter::repeat(' ').take(pending.indent as usize));
+                    if pending.insert_extra_newline {
+                        new_text = new_text.repeat(2);
+                    }
+                    buffer.edit_with_autoindent(pending.ranges, new_text, cx);
+                    delta += pending.delta;
+                }
+
+                let start = (range.start as isize + delta) as usize;
+                let end = (range.end as isize + delta) as usize;
+                let mut text_len = *indent as usize + 1;
+                if *insert_extra_newline {
+                    text_len *= 2;
+                }
+
+                let pending = pending_edit.get_or_insert_with(Default::default);
+                pending.delta += text_len as isize - (end - start) as isize;
+                pending.indent = *indent;
+                pending.insert_extra_newline = *insert_extra_newline;
+                pending.ranges.push(start..end);
+            }
+
+            let pending = pending_edit.unwrap();
+            let mut new_text = String::with_capacity(1 + pending.indent as usize);
+            new_text.push('\n');
+            new_text.extend(iter::repeat(' ').take(pending.indent as usize));
+            if pending.insert_extra_newline {
+                new_text = new_text.repeat(2);
+            }
+            buffer.edit_with_autoindent(pending.ranges, new_text, cx);
+
+            let mut delta = 0_isize;
+            new_selections.extend(old_selections.into_iter().map(
+                |(id, range, indent, insert_extra_newline)| {
+                    let start = (range.start as isize + delta) as usize;
+                    let end = (range.end as isize + delta) as usize;
+                    let text_before_cursor_len = indent as usize + 1;
+                    let anchor = buffer.anchor_before(start + text_before_cursor_len);
+                    let text_len = if insert_extra_newline {
+                        text_before_cursor_len * 2
+                    } else {
+                        text_before_cursor_len
+                    };
+                    delta += text_len as isize - (end - start) as isize;
+                    Selection {
+                        id,
+                        start: anchor.clone(),
+                        end: anchor,
+                        reversed: false,
+                        goal: SelectionGoal::None,
+                    }
+                },
+            ))
+        });
+
+        self.update_selections(new_selections, true, cx);
+        self.end_transaction(cx);
+
+        #[derive(Default)]
+        struct PendingEdit {
+            indent: u32,
+            insert_extra_newline: bool,
+            delta: isize,
+            ranges: SmallVec<[Range<usize>; 32]>,
+        }
+    }
+
     fn insert(&mut self, text: &str, cx: &mut ViewContext<Self>) {
         self.start_transaction(cx);
         let mut old_selections = SmallVec::<[_; 32]>::new();
@@ -766,7 +894,7 @@ impl Editor {
         let mut new_selections = Vec::new();
         self.buffer.update(cx, |buffer, cx| {
             let edit_ranges = old_selections.iter().map(|(_, range)| range.clone());
-            buffer.edit(edit_ranges, text, cx);
+            buffer.edit_with_autoindent(edit_ranges, text, cx);
             let text_len = text.len() as isize;
             let mut delta = 0_isize;
             new_selections = old_selections
@@ -797,7 +925,7 @@ impl Editor {
         let new_autoclose_pair_state = self.buffer.update(cx, |buffer, cx| {
             let autoclose_pair = buffer.language().and_then(|language| {
                 let first_selection_start = selections.first().unwrap().start.to_offset(&*buffer);
-                let pair = language.autoclose_pairs().iter().find(|pair| {
+                let pair = language.brackets().iter().find(|pair| {
                     buffer.contains_str_at(
                         first_selection_start.saturating_sub(pair.start.len()),
                         &pair.start,
@@ -832,7 +960,7 @@ impl Editor {
                 buffer.edit(selection_ranges, &pair.end, cx);
 
                 if pair.end.len() == 1 {
-                    Some(AutoclosePairState {
+                    Some(BracketPairState {
                         ranges: selections
                             .iter()
                             .map(|selection| {
@@ -950,6 +1078,51 @@ impl Editor {
         self.end_transaction(cx);
     }
 
+    pub fn tab(&mut self, _: &Tab, cx: &mut ViewContext<Self>) {
+        self.start_transaction(cx);
+        let tab_size = self.build_settings.borrow()(cx).tab_size;
+        let mut selections = self.selections(cx).to_vec();
+        self.buffer.update(cx, |buffer, cx| {
+            let mut last_indented_row = None;
+            for selection in &mut selections {
+                let mut range = selection.point_range(buffer);
+                if range.is_empty() {
+                    let char_column = buffer
+                        .chars_for_range(Point::new(range.start.row, 0)..range.start)
+                        .count();
+                    let chars_to_next_tab_stop = tab_size - (char_column % tab_size);
+                    buffer.edit(
+                        [range.start..range.start],
+                        " ".repeat(chars_to_next_tab_stop),
+                        cx,
+                    );
+                    range.start.column += chars_to_next_tab_stop as u32;
+
+                    let head = buffer.anchor_before(range.start);
+                    selection.start = head.clone();
+                    selection.end = head;
+                } else {
+                    for row in range.start.row..=range.end.row {
+                        if last_indented_row != Some(row) {
+                            let char_column = buffer.indent_column_for_line(row) as usize;
+                            let chars_to_next_tab_stop = tab_size - (char_column % tab_size);
+                            let row_start = Point::new(row, 0);
+                            buffer.edit(
+                                [row_start..row_start],
+                                " ".repeat(chars_to_next_tab_stop),
+                                cx,
+                            );
+                            last_indented_row = Some(row);
+                        }
+                    }
+                }
+            }
+        });
+
+        self.update_selections(selections, true, cx);
+        self.end_transaction(cx);
+    }
+
     pub fn delete_line(&mut self, _: &DeleteLine, cx: &mut ViewContext<Self>) {
         self.start_transaction(cx);
 
@@ -3507,6 +3680,30 @@ mod tests {
         assert_eq!(buffer.read(cx).text(), "e t te our");
     }
 
+    #[gpui::test]
+    fn test_newline(cx: &mut gpui::MutableAppContext) {
+        let buffer = cx.add_model(|cx| Buffer::new(0, "aaaa\n    bbbb\n", cx));
+        let settings = EditorSettings::test(&cx);
+        let (_, view) = cx.add_window(Default::default(), |cx| {
+            build_editor(buffer.clone(), settings, cx)
+        });
+
+        view.update(cx, |view, cx| {
+            view.select_display_ranges(
+                &[
+                    DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
+                    DisplayPoint::new(1, 2)..DisplayPoint::new(1, 2),
+                    DisplayPoint::new(1, 6)..DisplayPoint::new(1, 6),
+                ],
+                cx,
+            )
+            .unwrap();
+
+            view.newline(&Newline, cx);
+            assert_eq!(view.text(cx), "aa\naa\n  \n    bb\n    bb\n");
+        });
+    }
+
     #[gpui::test]
     fn test_backspace(cx: &mut gpui::MutableAppContext) {
         let buffer = cx.add_model(|cx| {
@@ -4355,14 +4552,18 @@ mod tests {
         let settings = cx.read(EditorSettings::test);
         let language = Arc::new(Language::new(
             LanguageConfig {
-                autoclose_pairs: vec![
-                    AutoclosePair {
+                brackets: vec![
+                    BracketPair {
                         start: "{".to_string(),
                         end: "}".to_string(),
+                        close: true,
+                        newline: true,
                     },
-                    AutoclosePair {
+                    BracketPair {
                         start: "/*".to_string(),
                         end: " */".to_string(),
+                        close: true,
+                        newline: true,
                     },
                 ],
                 ..Default::default()
@@ -4461,6 +4662,76 @@ mod tests {
         });
     }
 
+    #[gpui::test]
+    async fn test_extra_newline_insertion(mut cx: gpui::TestAppContext) {
+        let settings = cx.read(EditorSettings::test);
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                brackets: vec![
+                    BracketPair {
+                        start: "{".to_string(),
+                        end: "}".to_string(),
+                        close: true,
+                        newline: true,
+                    },
+                    BracketPair {
+                        start: "/* ".to_string(),
+                        end: " */".to_string(),
+                        close: true,
+                        newline: true,
+                    },
+                ],
+                ..Default::default()
+            },
+            tree_sitter_rust::language(),
+        ));
+
+        let text = concat!(
+            "{   }\n",     // Suppress rustfmt
+            "  x\n",       //
+            "  /*   */\n", //
+            "x\n",         //
+            "{{} }\n",     //
+        );
+
+        let buffer = cx.add_model(|cx| {
+            let history = History::new(text.into());
+            Buffer::from_history(0, history, None, Some(language), cx)
+        });
+        let (_, view) = cx.add_window(|cx| build_editor(buffer, settings, cx));
+        view.condition(&cx, |view, cx| !view.buffer.read(cx).is_parsing())
+            .await;
+
+        view.update(&mut cx, |view, cx| {
+            view.select_display_ranges(
+                &[
+                    DisplayPoint::new(0, 2)..DisplayPoint::new(0, 3),
+                    DisplayPoint::new(2, 5)..DisplayPoint::new(2, 5),
+                    DisplayPoint::new(4, 4)..DisplayPoint::new(4, 4),
+                ],
+                cx,
+            )
+            .unwrap();
+            view.newline(&Newline, cx);
+
+            assert_eq!(
+                view.buffer().read(cx).text(),
+                concat!(
+                    "{ \n",    // Suppress rustfmt
+                    "\n",      //
+                    "}\n",     //
+                    "  x\n",   //
+                    "  /* \n", //
+                    "  \n",    //
+                    "  */\n",  //
+                    "x\n",     //
+                    "{{} \n",  //
+                    "}\n",     //
+                )
+            );
+        });
+    }
+
     impl Editor {
         fn selection_ranges(&self, cx: &mut MutableAppContext) -> Vec<Range<DisplayPoint>> {
             self.selections_in_range(

crates/zed/languages/rust/config.toml

@@ -1,9 +1,10 @@
 name = "Rust"
 path_suffixes = ["rs"]
-autoclose_pairs = [
-    { start = "{", end = "}" },
-    { start = "[", end = "]" },
-    { start = "(", end = ")" },
-    { start = "\"", end = "\"" },
-    { start = "/*", end = " */" },
+brackets = [
+    { start = "{", end = "}", close = true, newline = true },
+    { start = "[", end = "]", close = true, newline = true },
+    { start = "(", end = ")", close = true, newline = true },
+    { start = "<", end = ">", close = false, newline = true },
+    { start = "\"", end = "\"", close = true, newline = false },
+    { start = "/*", end = " */", close = true, newline = false },
 ]

crates/zed/languages/rust/indents.scm

@@ -0,0 +1,12 @@
+[
+    ((where_clause) _ @end)
+    (field_expression)
+    (call_expression)
+    (assignment_expression)
+    (let_declaration)
+] @indent
+
+(_ "[" "]" @end) @indent
+(_ "<" ">" @end) @indent
+(_ "{" "}" @end) @indent
+(_ "(" ")" @end) @indent

crates/zed/src/language.rs

@@ -22,6 +22,8 @@ fn rust() -> Language {
         .unwrap()
         .with_brackets_query(load_query("rust/brackets.scm").as_ref())
         .unwrap()
+        .with_indents_query(load_query("rust/indents.scm").as_ref())
+        .unwrap()
 }
 
 fn load_query(path: &str) -> Cow<'static, str> {