Extract a language crate

Cargo.lock

@@ -1624,6 +1624,7 @@ dependencies = [
  "buffer",
  "clock",
  "gpui",
+ "language",
  "lazy_static",
  "log",
  "parking_lot",
@@ -2816,6 +2817,32 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "language"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "arrayvec 0.7.1",
+ "buffer",
+ "clock",
+ "gpui",
+ "lazy_static",
+ "log",
+ "parking_lot",
+ "rand 0.8.3",
+ "rpc",
+ "seahash",
+ "serde 1.0.125",
+ "similar",
+ "smallvec",
+ "smol",
+ "sum_tree",
+ "theme",
+ "tree-sitter",
+ "tree-sitter-rust",
+ "unindent",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -3760,6 +3787,7 @@ dependencies = [
  "fuzzy",
  "gpui",
  "ignore",
+ "language",
  "lazy_static",
  "libc",
  "log",
@@ -6106,6 +6134,7 @@ dependencies = [
  "client",
  "editor",
  "gpui",
+ "language",
  "log",
  "postage",
  "project",
@@ -6176,6 +6205,7 @@ dependencies = [
  "ignore",
  "image 0.23.14",
  "indexmap",
+ "language",
  "lazy_static",
  "libc",
  "log",

crates/buffer/src/anchor.rs

@@ -1,6 +1,6 @@
 use crate::Point;
 
-use super::{Buffer, Content};
+use super::{Content, TextBuffer};
 use anyhow::Result;
 use std::{cmp::Ordering, ops::Range};
 use sum_tree::Bias;
@@ -65,7 +65,7 @@ impl Anchor {
         Ok(offset_comparison.then_with(|| self.bias.cmp(&other.bias)))
     }
 
-    pub fn bias_left(&self, buffer: &Buffer) -> Anchor {
+    pub fn bias_left(&self, buffer: &TextBuffer) -> Anchor {
         if self.bias == Bias::Left {
             self.clone()
         } else {
@@ -73,7 +73,7 @@ impl Anchor {
         }
     }
 
-    pub fn bias_right(&self, buffer: &Buffer) -> Anchor {
+    pub fn bias_right(&self, buffer: &TextBuffer) -> Anchor {
         if self.bias == Bias::Right {
             self.clone()
         } else {

crates/buffer/src/selection.rs

@@ -1,4 +1,4 @@
-use crate::{Anchor, Buffer, Point, ToOffset as _, ToPoint as _};
+use crate::{Anchor, Point, TextBuffer, ToOffset as _, ToPoint as _};
 use std::{cmp::Ordering, mem, ops::Range};
 
 pub type SelectionSetId = clock::Lamport;
@@ -29,7 +29,7 @@ impl Selection {
         }
     }
 
-    pub fn set_head(&mut self, buffer: &Buffer, cursor: Anchor) {
+    pub fn set_head(&mut self, buffer: &TextBuffer, cursor: Anchor) {
         if cursor.cmp(self.tail(), buffer).unwrap() < Ordering::Equal {
             if !self.reversed {
                 mem::swap(&mut self.start, &mut self.end);
@@ -53,7 +53,7 @@ impl Selection {
         }
     }
 
-    pub fn point_range(&self, buffer: &Buffer) -> Range<Point> {
+    pub fn point_range(&self, buffer: &TextBuffer) -> Range<Point> {
         let start = self.start.to_point(buffer);
         let end = self.end.to_point(buffer);
         if self.reversed {
@@ -63,7 +63,7 @@ impl Selection {
         }
     }
 
-    pub fn offset_range(&self, buffer: &Buffer) -> Range<usize> {
+    pub fn offset_range(&self, buffer: &TextBuffer) -> Range<usize> {
         let start = self.start.to_offset(buffer);
         let end = self.end.to_offset(buffer);
         if self.reversed {

crates/buffer/src/tests.rs

@@ -1,2 +1,658 @@
-mod buffer;
+use super::*;
-mod syntax;
+use clock::ReplicaId;
+use rand::prelude::*;
+use std::{
+    cmp::Ordering,
+    env,
+    iter::Iterator,
+    time::{Duration, Instant},
+};
+
+#[test]
+fn test_edit() {
+    let mut buffer = TextBuffer::new(0, 0, History::new("abc".into()));
+    assert_eq!(buffer.text(), "abc");
+    buffer.edit(vec![3..3], "def");
+    assert_eq!(buffer.text(), "abcdef");
+    buffer.edit(vec![0..0], "ghi");
+    assert_eq!(buffer.text(), "ghiabcdef");
+    buffer.edit(vec![5..5], "jkl");
+    assert_eq!(buffer.text(), "ghiabjklcdef");
+    buffer.edit(vec![6..7], "");
+    assert_eq!(buffer.text(), "ghiabjlcdef");
+    buffer.edit(vec![4..9], "mno");
+    assert_eq!(buffer.text(), "ghiamnoef");
+}
+
+#[gpui::test(iterations = 100)]
+fn test_random_edits(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>();
+    let mut buffer = TextBuffer::new(0, 0, History::new(reference_string.clone().into()));
+    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_edit(&mut rng, 5);
+        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);
+            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);
+            delta += edit.delta();
+        }
+        assert_eq!(old_buffer.text(), buffer.text());
+    }
+}
+
+#[test]
+fn test_line_len() {
+    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
+    buffer.edit(vec![0..0], "abcd\nefg\nhij");
+    buffer.edit(vec![12..12], "kl\nmno");
+    buffer.edit(vec![18..18], "\npqrs\n");
+    buffer.edit(vec![18..21], "\nPQ");
+
+    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);
+}
+
+#[test]
+fn test_text_summary_for_range() {
+    let buffer = TextBuffer::new(0, 0, History::new("ab\nefg\nhklm\nnopqrs\ntuvwxyz".into()));
+    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,
+        }
+    );
+}
+
+#[test]
+fn test_chars_at() {
+    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
+    buffer.edit(vec![0..0], "abcd\nefgh\nij");
+    buffer.edit(vec![12..12], "kl\nmno");
+    buffer.edit(vec![18..18], "\npqrs");
+    buffer.edit(vec![18..21], "\nPQ");
+
+    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 = TextBuffer::new(0, 0, History::new("".into()));
+    buffer.edit(vec![0..0], "[workspace]\nmembers = [\n    \"xray_core\",\n    \"xray_server\",\n    \"xray_cli\",\n    \"xray_wasm\",\n]\n");
+    buffer.edit(vec![60..60], "\n");
+
+    let chars = buffer.chars_at(Point::new(6, 0));
+    assert_eq!(chars.collect::<String>(), "    \"xray_wasm\",\n]\n");
+}
+
+#[test]
+fn test_anchors() {
+    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
+    buffer.edit(vec![0..0], "abc");
+    let left_anchor = buffer.anchor_before(2);
+    let right_anchor = buffer.anchor_after(2);
+
+    buffer.edit(vec![1..1], "def\n");
+    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], "");
+    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");
+    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], "");
+    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
+    );
+}
+
+#[test]
+fn test_anchors_at_start_and_end() {
+    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
+    let before_start_anchor = buffer.anchor_before(0);
+    let after_end_anchor = buffer.anchor_after(0);
+
+    buffer.edit(vec![0..0], "abc");
+    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");
+    buffer.edit(vec![0..0], "ghi");
+    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);
+}
+
+#[test]
+fn test_undo_redo() {
+    let mut buffer = TextBuffer::new(0, 0, History::new("1234".into()));
+    // 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");
+    buffer.edit(vec![3..4], "yzef");
+    buffer.edit(vec![3..5], "cd");
+    assert_eq!(buffer.text(), "1abcdef234");
+
+    let transactions = buffer.history.undo_stack.clone();
+    assert_eq!(transactions.len(), 3);
+
+    buffer.undo_or_redo(transactions[0].clone()).unwrap();
+    assert_eq!(buffer.text(), "1cdef234");
+    buffer.undo_or_redo(transactions[0].clone()).unwrap();
+    assert_eq!(buffer.text(), "1abcdef234");
+
+    buffer.undo_or_redo(transactions[1].clone()).unwrap();
+    assert_eq!(buffer.text(), "1abcdx234");
+    buffer.undo_or_redo(transactions[2].clone()).unwrap();
+    assert_eq!(buffer.text(), "1abx234");
+    buffer.undo_or_redo(transactions[1].clone()).unwrap();
+    assert_eq!(buffer.text(), "1abyzef234");
+    buffer.undo_or_redo(transactions[2].clone()).unwrap();
+    assert_eq!(buffer.text(), "1abcdef234");
+
+    buffer.undo_or_redo(transactions[2].clone()).unwrap();
+    assert_eq!(buffer.text(), "1abyzef234");
+    buffer.undo_or_redo(transactions[0].clone()).unwrap();
+    assert_eq!(buffer.text(), "1yzef234");
+    buffer.undo_or_redo(transactions[1].clone()).unwrap();
+    assert_eq!(buffer.text(), "1234");
+}
+
+#[test]
+fn test_history() {
+    let mut now = Instant::now();
+    let mut buffer = TextBuffer::new(0, 0, History::new("123456".into()));
+
+    let set_id = if let Operation::UpdateSelections { set_id, .. } =
+        buffer.add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap())
+    {
+        set_id
+    } else {
+        unreachable!()
+    };
+    buffer.start_transaction_at(Some(set_id), now).unwrap();
+    buffer.edit(vec![2..4], "cd");
+    buffer.end_transaction_at(Some(set_id), now).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())
+        .unwrap();
+    buffer.edit(vec![4..5], "e");
+    buffer.end_transaction_at(Some(set_id), now).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())
+        .unwrap();
+    buffer.edit(vec![0..1], "a");
+    buffer.edit(vec![1..1], "b");
+    buffer.end_transaction_at(Some(set_id), now).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();
+    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();
+    assert_eq!(buffer.text(), "123456");
+    assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
+
+    // Redo the first two transactions together.
+    buffer.redo();
+    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();
+    assert_eq!(buffer.text(), "ab2cde6");
+    assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
+
+    buffer.start_transaction_at(None, now).unwrap();
+    assert!(buffer.end_transaction_at(None, now).is_none());
+    buffer.undo();
+    assert_eq!(buffer.text(), "12cde6");
+}
+
+#[test]
+fn test_concurrent_edits() {
+    let text = "abcdef";
+
+    let mut buffer1 = TextBuffer::new(1, 0, History::new(text.into()));
+    let mut buffer2 = TextBuffer::new(2, 0, History::new(text.into()));
+    let mut buffer3 = TextBuffer::new(3, 0, History::new(text.into()));
+
+    let buf1_op = buffer1.edit(vec![1..2], "12");
+    assert_eq!(buffer1.text(), "a12cdef");
+    let buf2_op = buffer2.edit(vec![3..4], "34");
+    assert_eq!(buffer2.text(), "abc34ef");
+    let buf3_op = buffer3.edit(vec![5..6], "56");
+    assert_eq!(buffer3.text(), "abcde56");
+
+    buffer1.apply_op(Operation::Edit(buf2_op.clone())).unwrap();
+    buffer1.apply_op(Operation::Edit(buf3_op.clone())).unwrap();
+    buffer2.apply_op(Operation::Edit(buf1_op.clone())).unwrap();
+    buffer2.apply_op(Operation::Edit(buf3_op.clone())).unwrap();
+    buffer3.apply_op(Operation::Edit(buf1_op.clone())).unwrap();
+    buffer3.apply_op(Operation::Edit(buf2_op.clone())).unwrap();
+
+    assert_eq!(buffer1.text(), "a12c34e56");
+    assert_eq!(buffer2.text(), "a12c34e56");
+    assert_eq!(buffer3.text(), "a12c34e56");
+}
+
+#[gpui::test(iterations = 100)]
+fn test_random_concurrent_edits(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 mut buffer = TextBuffer::new(i as ReplicaId, 0, History::new(base_text.clone().into()));
+        buffer.history.group_interval = Duration::from_millis(rng.gen_range(0..=200));
+        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];
+        let buffer = &mut buffers[replica_index];
+        match rng.gen_range(0..=100) {
+            0..=50 if mutation_count != 0 => {
+                let ops = buffer.randomly_mutate(&mut rng);
+                network.broadcast(buffer.replica_id, ops);
+                log::info!("buffer {} text: {:?}", buffer.replica_id, buffer.text());
+                mutation_count -= 1;
+            }
+            51..=70 if mutation_count != 0 => {
+                let ops = buffer.randomly_undo_redo(&mut rng);
+                network.broadcast(buffer.replica_id, ops);
+                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).unwrap();
+                }
+            }
+            _ => {}
+        }
+
+        if mutation_count == 0 && network.is_idle() {
+            break;
+        }
+    }
+
+    let first_buffer = &buffers[0];
+    for buffer in &buffers[1..] {
+        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/buffer.rs

@@ -1,733 +0,0 @@
-use crate::*;
-use clock::ReplicaId;
-use rand::prelude::*;
-use std::{
-    cell::RefCell,
-    cmp::Ordering,
-    env,
-    iter::Iterator,
-    rc::Rc,
-    time::{Duration, Instant},
-};
-
-#[test]
-fn test_edit() {
-    let mut buffer = TextBuffer::new(0, 0, History::new("abc".into()));
-    assert_eq!(buffer.text(), "abc");
-    buffer.edit(vec![3..3], "def");
-    assert_eq!(buffer.text(), "abcdef");
-    buffer.edit(vec![0..0], "ghi");
-    assert_eq!(buffer.text(), "ghiabcdef");
-    buffer.edit(vec![5..5], "jkl");
-    assert_eq!(buffer.text(), "ghiabjklcdef");
-    buffer.edit(vec![6..7], "");
-    assert_eq!(buffer.text(), "ghiabjlcdef");
-    buffer.edit(vec![4..9], "mno");
-    assert_eq!(buffer.text(), "ghiamnoef");
-}
-
-#[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(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>();
-    let mut buffer = TextBuffer::new(0, 0, History::new(reference_string.clone().into()));
-    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_edit(&mut rng, 5);
-        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);
-            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);
-            delta += edit.delta();
-        }
-        assert_eq!(old_buffer.text(), buffer.text());
-    }
-}
-
-#[test]
-fn test_line_len() {
-    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
-    buffer.edit(vec![0..0], "abcd\nefg\nhij");
-    buffer.edit(vec![12..12], "kl\nmno");
-    buffer.edit(vec![18..18], "\npqrs\n");
-    buffer.edit(vec![18..21], "\nPQ");
-
-    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);
-}
-
-#[test]
-fn test_text_summary_for_range() {
-    let buffer = TextBuffer::new(0, 0, History::new("ab\nefg\nhklm\nnopqrs\ntuvwxyz".into()));
-    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,
-        }
-    );
-}
-
-#[test]
-fn test_chars_at() {
-    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
-    buffer.edit(vec![0..0], "abcd\nefgh\nij");
-    buffer.edit(vec![12..12], "kl\nmno");
-    buffer.edit(vec![18..18], "\npqrs");
-    buffer.edit(vec![18..21], "\nPQ");
-
-    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 = TextBuffer::new(0, 0, History::new("".into()));
-    buffer.edit(vec![0..0], "[workspace]\nmembers = [\n    \"xray_core\",\n    \"xray_server\",\n    \"xray_cli\",\n    \"xray_wasm\",\n]\n");
-    buffer.edit(vec![60..60], "\n");
-
-    let chars = buffer.chars_at(Point::new(6, 0));
-    assert_eq!(chars.collect::<String>(), "    \"xray_wasm\",\n]\n");
-}
-
-#[test]
-fn test_anchors() {
-    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
-    buffer.edit(vec![0..0], "abc");
-    let left_anchor = buffer.anchor_before(2);
-    let right_anchor = buffer.anchor_after(2);
-
-    buffer.edit(vec![1..1], "def\n");
-    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], "");
-    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");
-    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], "");
-    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
-    );
-}
-
-#[test]
-fn test_anchors_at_start_and_end() {
-    let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
-    let before_start_anchor = buffer.anchor_before(0);
-    let after_end_anchor = buffer.anchor_after(0);
-
-    buffer.edit(vec![0..0], "abc");
-    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");
-    buffer.edit(vec![0..0], "ghi");
-    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);
-}
-
-#[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));
-}
-
-#[test]
-fn test_undo_redo() {
-    let mut buffer = TextBuffer::new(0, 0, History::new("1234".into()));
-    // 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");
-    buffer.edit(vec![3..4], "yzef");
-    buffer.edit(vec![3..5], "cd");
-    assert_eq!(buffer.text(), "1abcdef234");
-
-    let transactions = buffer.history.undo_stack.clone();
-    assert_eq!(transactions.len(), 3);
-
-    buffer.undo_or_redo(transactions[0].clone()).unwrap();
-    assert_eq!(buffer.text(), "1cdef234");
-    buffer.undo_or_redo(transactions[0].clone()).unwrap();
-    assert_eq!(buffer.text(), "1abcdef234");
-
-    buffer.undo_or_redo(transactions[1].clone()).unwrap();
-    assert_eq!(buffer.text(), "1abcdx234");
-    buffer.undo_or_redo(transactions[2].clone()).unwrap();
-    assert_eq!(buffer.text(), "1abx234");
-    buffer.undo_or_redo(transactions[1].clone()).unwrap();
-    assert_eq!(buffer.text(), "1abyzef234");
-    buffer.undo_or_redo(transactions[2].clone()).unwrap();
-    assert_eq!(buffer.text(), "1abcdef234");
-
-    buffer.undo_or_redo(transactions[2].clone()).unwrap();
-    assert_eq!(buffer.text(), "1abyzef234");
-    buffer.undo_or_redo(transactions[0].clone()).unwrap();
-    assert_eq!(buffer.text(), "1yzef234");
-    buffer.undo_or_redo(transactions[1].clone()).unwrap();
-    assert_eq!(buffer.text(), "1234");
-}
-
-#[test]
-fn test_history() {
-    let mut now = Instant::now();
-    let mut buffer = TextBuffer::new(0, 0, History::new("123456".into()));
-
-    let set_id = if let Operation::UpdateSelections { set_id, .. } =
-        buffer.add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap())
-    {
-        set_id
-    } else {
-        unreachable!()
-    };
-    buffer.start_transaction_at(Some(set_id), now).unwrap();
-    buffer.edit(vec![2..4], "cd");
-    buffer.end_transaction_at(Some(set_id), now).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())
-        .unwrap();
-    buffer.edit(vec![4..5], "e");
-    buffer.end_transaction_at(Some(set_id), now).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())
-        .unwrap();
-    buffer.edit(vec![0..1], "a");
-    buffer.edit(vec![1..1], "b");
-    buffer.end_transaction_at(Some(set_id), now).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();
-    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();
-    assert_eq!(buffer.text(), "123456");
-    assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
-
-    // Redo the first two transactions together.
-    buffer.redo();
-    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();
-    assert_eq!(buffer.text(), "ab2cde6");
-    assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
-
-    buffer.start_transaction_at(None, now).unwrap();
-    assert!(buffer.end_transaction_at(None, now).is_none());
-    buffer.undo();
-    assert_eq!(buffer.text(), "12cde6");
-}
-
-#[test]
-fn test_concurrent_edits() {
-    let text = "abcdef";
-
-    let mut buffer1 = TextBuffer::new(1, 0, History::new(text.into()));
-    let mut buffer2 = TextBuffer::new(2, 0, History::new(text.into()));
-    let mut buffer3 = TextBuffer::new(3, 0, History::new(text.into()));
-
-    let buf1_op = buffer1.edit(vec![1..2], "12");
-    assert_eq!(buffer1.text(), "a12cdef");
-    let buf2_op = buffer2.edit(vec![3..4], "34");
-    assert_eq!(buffer2.text(), "abc34ef");
-    let buf3_op = buffer3.edit(vec![5..6], "56");
-    assert_eq!(buffer3.text(), "abcde56");
-
-    buffer1.apply_op(Operation::Edit(buf2_op.clone())).unwrap();
-    buffer1.apply_op(Operation::Edit(buf3_op.clone())).unwrap();
-    buffer2.apply_op(Operation::Edit(buf1_op.clone())).unwrap();
-    buffer2.apply_op(Operation::Edit(buf3_op.clone())).unwrap();
-    buffer3.apply_op(Operation::Edit(buf1_op.clone())).unwrap();
-    buffer3.apply_op(Operation::Edit(buf2_op.clone())).unwrap();
-
-    assert_eq!(buffer1.text(), "a12c34e56");
-    assert_eq!(buffer2.text(), "a12c34e56");
-    assert_eq!(buffer3.text(), "a12c34e56");
-}
-
-#[gpui::test(iterations = 100)]
-fn test_random_concurrent_edits(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 mut buffer = TextBuffer::new(i as ReplicaId, 0, History::new(base_text.clone().into()));
-        buffer.history.group_interval = Duration::from_millis(rng.gen_range(0..=200));
-        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];
-        let buffer = &mut buffers[replica_index];
-        match rng.gen_range(0..=100) {
-            0..=50 if mutation_count != 0 => {
-                let ops = buffer.randomly_mutate(&mut rng);
-                network.broadcast(buffer.replica_id, ops);
-                log::info!("buffer {} text: {:?}", buffer.replica_id, buffer.text());
-                mutation_count -= 1;
-            }
-            51..=70 if mutation_count != 0 => {
-                let ops = buffer.randomly_undo_redo(&mut rng);
-                network.broadcast(buffer.replica_id, ops);
-                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).unwrap();
-                }
-            }
-            _ => {}
-        }
-
-        if mutation_count == 0 && network.is_idle() {
-            break;
-        }
-    }
-
-    let first_buffer = &buffers[0];
-    for buffer in &buffers[1..] {
-        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/editor/Cargo.toml

@@ -10,6 +10,7 @@ test-support = ["buffer/test-support", "gpui/test-support"]
 buffer = { path = "../buffer" }
 clock = { path = "../clock" }
 gpui = { path = "../gpui" }
+language = { path = "../language" }
 sum_tree = { path = "../sum_tree" }
 theme = { path = "../theme" }
 util = { path = "../util" }
@@ -24,6 +25,7 @@ smol = "1.2"
 
 [dev-dependencies]
 buffer = { path = "../buffer", features = ["test-support"] }
+language = { path = "../language", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 rand = "0.8"
 unindent = "0.1.7"

crates/editor/src/display_map.rs

@@ -2,9 +2,9 @@ mod fold_map;
 mod tab_map;
 mod wrap_map;
 
-use buffer::{Anchor, Buffer, Point, ToOffset, ToPoint};
 use fold_map::{FoldMap, ToFoldPoint as _};
 use gpui::{fonts::FontId, Entity, ModelContext, ModelHandle};
+use language::{Anchor, Buffer, Point, ToOffset, ToPoint};
 use std::ops::Range;
 use sum_tree::Bias;
 use tab_map::TabMap;
@@ -109,7 +109,7 @@ impl DisplayMap {
 }
 
 pub struct DisplayMapSnapshot {
-    buffer_snapshot: buffer::Snapshot,
+    buffer_snapshot: language::Snapshot,
     folds_snapshot: fold_map::Snapshot,
     tabs_snapshot: tab_map::Snapshot,
     wraps_snapshot: wrap_map::Snapshot,
@@ -358,8 +358,8 @@ impl ToDisplayPoint for Anchor {
 mod tests {
     use super::*;
     use crate::{movement, test::*};
-    use buffer::{History, Language, LanguageConfig, RandomCharIter, SelectionGoal};
     use gpui::{color::Color, MutableAppContext};
+    use language::{History, Language, LanguageConfig, RandomCharIter, SelectionGoal};
     use rand::{prelude::StdRng, Rng};
     use std::{env, sync::Arc};
     use theme::SyntaxTheme;
@@ -436,7 +436,7 @@ mod tests {
                     }
                 }
                 _ => {
-                    buffer.update(&mut cx, |buffer, cx| buffer.randomly_edit(&mut rng, 5));
+                    buffer.update(&mut cx, |buffer, _| buffer.randomly_edit(&mut rng, 5));
                 }
             }
 

crates/editor/src/display_map/fold_map.rs

@@ -1,5 +1,5 @@
-use buffer::{Anchor, AnchorRangeExt, Buffer, HighlightId, Point, TextSummary, ToOffset};
 use gpui::{AppContext, ModelHandle};
+use language::{Anchor, AnchorRangeExt, Buffer, HighlightId, Point, TextSummary, ToOffset};
 use parking_lot::Mutex;
 use std::{
     cmp::{self, Ordering},
@@ -485,7 +485,7 @@ impl FoldMap {
 pub struct Snapshot {
     transforms: SumTree<Transform>,
     folds: SumTree<Fold>,
-    buffer_snapshot: buffer::Snapshot,
+    buffer_snapshot: language::Snapshot,
     pub version: usize,
 }
 
@@ -994,7 +994,7 @@ impl<'a> Iterator for Chunks<'a> {
 
 pub struct HighlightedChunks<'a> {
     transform_cursor: Cursor<'a, Transform, (FoldOffset, usize)>,
-    buffer_chunks: buffer::HighlightedChunks<'a>,
+    buffer_chunks: language::HighlightedChunks<'a>,
     buffer_chunk: Option<(usize, &'a str, HighlightId)>,
     buffer_offset: usize,
 }
@@ -1331,7 +1331,7 @@ mod tests {
                     snapshot_edits.extend(map.randomly_mutate(&mut rng, cx.as_ref()));
                 }
                 _ => {
-                    let edits = buffer.update(cx, |buffer, cx| {
+                    let edits = buffer.update(cx, |buffer, _| {
                         let start_version = buffer.version.clone();
                         let edit_count = rng.gen_range(1..=5);
                         buffer.randomly_edit(&mut rng, edit_count);

crates/editor/src/display_map/tab_map.rs

@@ -1,5 +1,5 @@
 use super::fold_map::{self, FoldEdit, FoldPoint, Snapshot as FoldSnapshot};
-use buffer::{rope, HighlightId};
+use language::{rope, HighlightId};
 use parking_lot::Mutex;
 use std::{mem, ops::Range};
 use sum_tree::Bias;

crates/editor/src/display_map/wrap_map.rs

@@ -2,8 +2,8 @@ use super::{
     fold_map,
     tab_map::{self, Edit as TabEdit, Snapshot as TabSnapshot, TabPoint, TextSummary},
 };
-use buffer::{HighlightId, Point};
 use gpui::{fonts::FontId, text_layout::LineWrapper, Entity, ModelContext, Task};
+use language::{HighlightId, Point};
 use lazy_static::lazy_static;
 use smol::future::yield_now;
 use std::{collections::VecDeque, ops::Range, time::Duration};
@@ -899,7 +899,7 @@ mod tests {
         display_map::{fold_map::FoldMap, tab_map::TabMap},
         test::Observer,
     };
-    use buffer::{Buffer, RandomCharIter};
+    use language::{Buffer, RandomCharIter};
     use rand::prelude::*;
     use std::env;
 
@@ -990,7 +990,7 @@ mod tests {
                     }
                 }
                 _ => {
-                    buffer.update(&mut cx, |buffer, cx| buffer.randomly_mutate(&mut rng));
+                    buffer.update(&mut cx, |buffer, _| buffer.randomly_mutate(&mut rng));
                 }
             }
 

crates/editor/src/element.rs

@@ -2,7 +2,6 @@ use super::{
     DisplayPoint, Editor, EditorMode, EditorSettings, EditorStyle, Input, Scroll, Select,
     SelectPhase, Snapshot, MAX_LINE_LEN,
 };
-use buffer::HighlightId;
 use clock::ReplicaId;
 use gpui::{
     color::Color,
@@ -18,6 +17,7 @@ use gpui::{
     MutableAppContext, PaintContext, Quad, Scene, SizeConstraint, ViewContext, WeakViewHandle,
 };
 use json::json;
+use language::HighlightId;
 use smallvec::SmallVec;
 use std::{
     cmp::{self, Ordering},
@@ -1043,7 +1043,7 @@ mod tests {
         test::sample_text,
         {Editor, EditorSettings},
     };
-    use buffer::Buffer;
+    use language::Buffer;
 
     #[gpui::test]
     fn test_layout_line_numbers(cx: &mut gpui::MutableAppContext) {

crates/editor/src/lib.rs

@@ -5,7 +5,6 @@ pub mod movement;
 #[cfg(test)]
 mod test;
 
-use buffer::*;
 use clock::ReplicaId;
 pub use display_map::DisplayPoint;
 use display_map::*;
@@ -15,6 +14,7 @@ use gpui::{
     text_layout, AppContext, ClipboardItem, Element, ElementBox, Entity, ModelHandle,
     MutableAppContext, RenderContext, View, ViewContext, WeakViewHandle,
 };
+use language::*;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use smol::Timer;
@@ -2661,17 +2661,17 @@ impl Editor {
     fn on_buffer_event(
         &mut self,
         _: ModelHandle<Buffer>,
-        event: &buffer::Event,
+        event: &language::Event,
         cx: &mut ViewContext<Self>,
     ) {
         match event {
-            buffer::Event::Edited => cx.emit(Event::Edited),
+            language::Event::Edited => cx.emit(Event::Edited),
-            buffer::Event::Dirtied => cx.emit(Event::Dirtied),
+            language::Event::Dirtied => cx.emit(Event::Dirtied),
-            buffer::Event::Saved => cx.emit(Event::Saved),
+            language::Event::Saved => cx.emit(Event::Saved),
-            buffer::Event::FileHandleChanged => cx.emit(Event::FileHandleChanged),
+            language::Event::FileHandleChanged => cx.emit(Event::FileHandleChanged),
-            buffer::Event::Reloaded => cx.emit(Event::FileHandleChanged),
+            language::Event::Reloaded => cx.emit(Event::FileHandleChanged),
-            buffer::Event::Closed => cx.emit(Event::Closed),
+            language::Event::Closed => cx.emit(Event::Closed),
-            buffer::Event::Reparsed => {}
+            language::Event::Reparsed => {}
         }
     }
 

crates/language/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "language"
+version = "0.1.0"
+edition = "2018"
+
+[features]
+test-support = ["rand"]
+
+[dependencies]
+buffer = { path = "../buffer" }
+clock = { path = "../clock" }
+gpui = { path = "../gpui" }
+rpc = { path = "../rpc" }
+sum_tree = { path = "../sum_tree" }
+theme = { path = "../theme" }
+anyhow = "1.0.38"
+arrayvec = "0.7.1"
+lazy_static = "1.4"
+log = "0.4"
+parking_lot = "0.11.1"
+rand = { version = "0.8.3", optional = true }
+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]
+buffer = { path = "../buffer", features = ["test-support"] }
+gpui = { path = "../gpui", features = ["test-support"] }
+
+rand = "0.8.3"
+tree-sitter-rust = "0.19.0"
+unindent = "0.1.7"

crates/language/src/tests.rs

@@ -1,7 +1,81 @@
-use crate::*;
+use super::*;
 use gpui::{ModelHandle, MutableAppContext};
+use std::rc::Rc;
 use unindent::Unindent as _;
 
+#[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]
+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]
 async fn test_reparse(mut cx: gpui::TestAppContext) {
     let buffer = cx.add_model(|cx| {

crates/project/Cargo.toml

@@ -12,6 +12,7 @@ clock = { path = "../clock" }
 fsevent = { path = "../fsevent" }
 fuzzy = { path = "../fuzzy" }
 gpui = { path = "../gpui" }
+language = { path = "../language" }
 client = { path = "../client" }
 sum_tree = { path = "../sum_tree" }
 util = { path = "../util" }
@@ -33,6 +34,7 @@ toml = "0.5"
 
 [dev-dependencies]
 client = { path = "../client", features = ["test-support"] }
+language = { path = "../language", features = ["test-support"] }
 util = { path = "../util", features = ["test-support"] }
 rpc = { path = "../rpc", features = ["test-support"] }
 

crates/project/src/lib.rs

@@ -3,11 +3,11 @@ mod ignore;
 mod worktree;
 
 use anyhow::Result;
-use buffer::LanguageRegistry;
 use client::Client;
 use futures::Future;
 use fuzzy::{PathMatch, PathMatchCandidate, PathMatchCandidateSet};
 use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
+use language::LanguageRegistry;
 use std::{
     path::Path,
     sync::{atomic::AtomicBool, Arc},
@@ -302,9 +302,9 @@ impl Entity for Project {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use buffer::LanguageRegistry;
     use fs::RealFs;
     use gpui::TestAppContext;
+    use language::LanguageRegistry;
     use serde_json::json;
     use std::{os::unix, path::PathBuf};
     use util::test::temp_tree;

crates/project/src/worktree.rs

@@ -4,7 +4,6 @@ use super::{
 };
 use ::ignore::gitignore::{Gitignore, GitignoreBuilder};
 use anyhow::{anyhow, Result};
-use buffer::{Buffer, History, LanguageRegistry, Operation, Rope};
 use client::{proto, Client, PeerId, TypedEnvelope};
 use clock::ReplicaId;
 use futures::{Stream, StreamExt};
@@ -13,6 +12,7 @@ use gpui::{
     executor, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext,
     Task, UpgradeModelHandle, WeakModelHandle,
 };
+use language::{Buffer, History, LanguageRegistry, Operation, Rope};
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use postage::{
@@ -627,14 +627,14 @@ impl Worktree {
                             file_changed = true;
                         } else if !file.is_deleted() {
                             if buffer_is_clean {
-                                cx.emit(buffer::Event::Dirtied);
+                                cx.emit(language::Event::Dirtied);
                             }
                             file.set_entry_id(None);
                             file_changed = true;
                         }
 
                         if file_changed {
-                            cx.emit(buffer::Event::FileHandleChanged);
+                            cx.emit(language::Event::FileHandleChanged);
                         }
                     }
                 });
@@ -862,7 +862,7 @@ impl LocalWorktree {
                     .update(&mut cx, |this, cx| this.as_local().unwrap().load(&path, cx))
                     .await?;
                 let language = this.read_with(&cx, |this, cx| {
-                    use buffer::File;
+                    use language::File;
 
                     this.languages()
                         .select_language(file.full_path(cx))
@@ -909,7 +909,7 @@ impl LocalWorktree {
                     .insert(buffer.id() as u64, buffer.clone());
 
                 Ok(proto::OpenBufferResponse {
-                    buffer: Some(buffer.update(cx.as_mut(), |buffer, cx| buffer.to_proto(cx))),
+                    buffer: Some(buffer.update(cx.as_mut(), |buffer, _| buffer.to_proto())),
                 })
             })
         })
@@ -1279,7 +1279,7 @@ impl RemoteWorktree {
                     .ok_or_else(|| anyhow!("worktree was closed"))?;
                 let file = File::new(entry.id, this.clone(), entry.path, entry.mtime);
                 let language = this.read_with(&cx, |this, cx| {
-                    use buffer::File;
+                    use language::File;
 
                     this.languages()
                         .select_language(file.full_path(cx))
@@ -1790,7 +1790,7 @@ impl File {
     }
 }
 
-impl buffer::File for File {
+impl language::File for File {
     fn worktree_id(&self) -> usize {
         self.worktree.id()
     }
@@ -1942,7 +1942,7 @@ impl buffer::File for File {
         });
     }
 
-    fn boxed_clone(&self) -> Box<dyn buffer::File> {
+    fn boxed_clone(&self) -> Box<dyn language::File> {
         Box::new(self.clone())
     }
 
@@ -3268,7 +3268,7 @@ mod tests {
             assert!(buffer.is_dirty());
             assert_eq!(
                 *events.borrow(),
-                &[buffer::Event::Edited, buffer::Event::Dirtied]
+                &[language::Event::Edited, language::Event::Dirtied]
             );
             events.borrow_mut().clear();
             buffer.did_save(buffer.version(), buffer.file().unwrap().mtime(), None, cx);
@@ -3277,7 +3277,7 @@ mod tests {
         // after saving, the buffer is not dirty, and emits a saved event.
         buffer1.update(&mut cx, |buffer, cx| {
             assert!(!buffer.is_dirty());
-            assert_eq!(*events.borrow(), &[buffer::Event::Saved]);
+            assert_eq!(*events.borrow(), &[language::Event::Saved]);
             events.borrow_mut().clear();
 
             buffer.edit(vec![1..1], "B", cx);
@@ -3291,9 +3291,9 @@ mod tests {
             assert_eq!(
                 *events.borrow(),
                 &[
-                    buffer::Event::Edited,
+                    language::Event::Edited,
-                    buffer::Event::Dirtied,
+                    language::Event::Dirtied,
-                    buffer::Event::Edited
+                    language::Event::Edited
                 ],
             );
             events.borrow_mut().clear();
@@ -3305,7 +3305,7 @@ mod tests {
             assert!(buffer.is_dirty());
         });
 
-        assert_eq!(*events.borrow(), &[buffer::Event::Edited]);
+        assert_eq!(*events.borrow(), &[language::Event::Edited]);
 
         // When a file is deleted, the buffer is considered dirty.
         let events = Rc::new(RefCell::new(Vec::new()));
@@ -3325,7 +3325,7 @@ mod tests {
         buffer2.condition(&cx, |b, _| b.is_dirty()).await;
         assert_eq!(
             *events.borrow(),
-            &[buffer::Event::Dirtied, buffer::Event::FileHandleChanged]
+            &[language::Event::Dirtied, language::Event::FileHandleChanged]
         );
 
         // When a file is already dirty when deleted, we don't emit a Dirtied event.
@@ -3351,7 +3351,7 @@ mod tests {
         buffer3
             .condition(&cx, |_, _| !events.borrow().is_empty())
             .await;
-        assert_eq!(*events.borrow(), &[buffer::Event::FileHandleChanged]);
+        assert_eq!(*events.borrow(), &[language::Event::FileHandleChanged]);
         cx.read(|cx| assert!(buffer3.read(cx).is_dirty()));
     }
 

crates/server/src/rpc.rs

@@ -976,13 +976,13 @@ mod tests {
         time::Duration,
     };
     use zed::{
-        buffer::LanguageRegistry,
         client::{
             self, test::FakeHttpClient, Channel, ChannelDetails, ChannelList, Client, Credentials,
             EstablishConnectionError, UserStore,
         },
         editor::{Editor, EditorSettings, Input},
         fs::{FakeFs, Fs as _},
+        language::LanguageRegistry,
         people_panel::JoinWorktree,
         project::{ProjectPath, Worktree},
         workspace::{Workspace, WorkspaceParams},

crates/workspace/Cargo.toml

@@ -8,7 +8,7 @@ test-support = [
     "client/test-support",
     "project/test-support",
     "tree-sitter",
-    "tree-sitter-rust"
+    "tree-sitter-rust",
 ]
 
 [dependencies]
@@ -16,6 +16,7 @@ buffer = { path = "../buffer" }
 client = { path = "../client" }
 editor = { path = "../editor" }
 gpui = { path = "../gpui" }
+language = { path = "../language" }
 project = { path = "../project" }
 theme = { path = "../theme" }
 anyhow = "1.0.38"

crates/workspace/src/items.rs

@@ -1,9 +1,9 @@
 use super::{Item, ItemView};
 use crate::Settings;
 use anyhow::Result;
-use buffer::{Buffer, File as _};
 use editor::{Editor, EditorSettings, Event};
 use gpui::{fonts::TextStyle, AppContext, ModelHandle, Task, ViewContext};
+use language::{Buffer, File as _};
 use postage::watch;
 use project::{ProjectPath, Worktree};
 use std::path::Path;

crates/workspace/src/lib.rs

@@ -5,7 +5,7 @@ pub mod settings;
 pub mod sidebar;
 
 use anyhow::Result;
-use buffer::{Buffer, LanguageRegistry};
+use language::{Buffer, LanguageRegistry};
 use client::{Authenticate, ChannelList, Client, UserStore};
 use gpui::{
     action, elements::*, json::to_string_pretty, keymap::Binding, platform::CursorStyle,
@@ -271,8 +271,8 @@ impl WorkspaceParams {
     #[cfg(any(test, feature = "test-support"))]
     pub fn test(cx: &mut MutableAppContext) -> Self {
         let mut languages = LanguageRegistry::new();
-        languages.add(Arc::new(buffer::Language::new(
+        languages.add(Arc::new(language::Language::new(
-            buffer::LanguageConfig {
+            language::LanguageConfig {
                 name: "Rust".to_string(),
                 path_suffixes: vec!["rs".to_string()],
                 ..Default::default()

crates/zed/Cargo.toml

@@ -18,6 +18,7 @@ test-support = [
     "buffer/test-support",
     "client/test-support",
     "gpui/test-support",
+    "language/test-support",
     "project/test-support",
     "rpc/test-support",
     "tempdir",
@@ -33,6 +34,7 @@ fuzzy = { path = "../fuzzy" }
 editor = { path = "../editor" }
 file_finder = { path = "../file_finder" }
 gpui = { path = "../gpui" }
+language = { path = "../language" }
 people_panel = { path = "../people_panel" }
 project = { path = "../project" }
 project_panel = { path = "../project_panel" }
@@ -85,6 +87,7 @@ url = "2.2"
 buffer = { path = "../buffer", features = ["test-support"] }
 editor = { path = "../editor", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
+language = { path = "../language", features = ["test-support"] }
 project = { path = "../project", features = ["test-support"] }
 rpc = { path = "../rpc", features = ["test-support"] }
 client = { path = "../client", features = ["test-support"] }

crates/zed/src/language.rs

@@ -1,4 +1,4 @@
-use buffer::{Language, LanguageRegistry};
+pub use language::{Language, LanguageRegistry};
 use rust_embed::RustEmbed;
 use std::borrow::Cow;
 use std::{str, sync::Arc};

crates/zed/src/lib.rs

@@ -4,8 +4,7 @@ pub mod menus;
 #[cfg(any(test, feature = "test-support"))]
 pub mod test;
 
-pub use buffer;
+use self::language::LanguageRegistry;
-use buffer::LanguageRegistry;
 use chat_panel::ChatPanel;
 pub use client;
 pub use editor;

crates/zed/src/test.rs

@@ -1,7 +1,7 @@
 use crate::{assets::Assets, AppState};
-use buffer::LanguageRegistry;
 use client::{http::ServerResponse, test::FakeHttpClient, ChannelList, Client, UserStore};
 use gpui::{AssetSource, MutableAppContext};
+use language::LanguageRegistry;
 use parking_lot::Mutex;
 use postage::watch;
 use project::fs::FakeFs;