Merge branch 'main' into polish-project-diagnostics

crates/clock/src/clock.rs

@@ -178,7 +178,7 @@ impl Global {
         }
     }
 
-    pub fn ge(&self, other: &Self) -> bool {
+    pub fn observed_all(&self, other: &Self) -> bool {
         let mut lhs = self.0.iter();
         let mut rhs = other.0.iter();
         loop {
@@ -196,22 +196,16 @@ impl Global {
         }
     }
 
-    pub fn gt(&self, other: &Self) -> bool {
+    pub fn changed_since(&self, other: &Self) -> bool {
-        let mut lhs = self.0.iter();
+        if self.0.len() > other.0.len() {
-        let mut rhs = other.0.iter();
+            return true;
-        loop {
+        }
-            if let Some(left) = lhs.next() {
+        for (left, right) in self.0.iter().zip(other.0.iter()) {
-                if let Some(right) = rhs.next() {
+            if left > right {
-                    if left <= right {
+                return true;
-                        return false;
-                    }
-                } else {
-                    return true;
-                }
-            } else {
-                return rhs.next().is_none();
             }
         }
+        false
     }
 
     pub fn iter<'a>(&'a self) -> impl 'a + Iterator<Item = Local> {

crates/editor/src/multi_buffer.rs

@@ -804,7 +804,7 @@ impl MultiBuffer {
             let selections_update_count = buffer.selections_update_count();
             let diagnostics_update_count = buffer.diagnostics_update_count();
 
-            let buffer_edited = version.gt(&buffer_state.last_version);
+            let buffer_edited = version.changed_since(&buffer_state.last_version);
             let buffer_reparsed = parse_count > buffer_state.last_parse_count;
             let buffer_selections_updated =
                 selections_update_count > buffer_state.last_selections_update_count;
@@ -2120,6 +2120,26 @@ mod tests {
         );
     }
 
+    #[gpui::test]
+    fn test_remote_multibuffer(cx: &mut MutableAppContext) {
+        let host_buffer = cx.add_model(|cx| Buffer::new(0, "a", cx));
+        let guest_buffer = cx.add_model(|cx| {
+            let message = host_buffer.read(cx).to_proto();
+            Buffer::from_proto(1, message, None, cx).unwrap()
+        });
+        let multibuffer = cx.add_model(|cx| MultiBuffer::singleton(guest_buffer.clone(), cx));
+        let snapshot = multibuffer.read(cx).snapshot(cx);
+        assert_eq!(snapshot.text(), "a");
+
+        guest_buffer.update(cx, |buffer, cx| buffer.edit([1..1], "b", cx));
+        let snapshot = multibuffer.read(cx).snapshot(cx);
+        assert_eq!(snapshot.text(), "ab");
+
+        guest_buffer.update(cx, |buffer, cx| buffer.edit([2..2], "c", cx));
+        let snapshot = multibuffer.read(cx).snapshot(cx);
+        assert_eq!(snapshot.text(), "abc");
+    }
+
     #[gpui::test]
     fn test_excerpt_buffer(cx: &mut MutableAppContext) {
         let buffer_1 = cx.add_model(|cx| Buffer::new(0, sample_text(6, 6, 'a'), cx));

crates/language/src/buffer.rs

@@ -712,7 +712,8 @@ impl Buffer {
                             let grammar_changed = this
                                 .grammar()
                                 .map_or(true, |curr_grammar| !Arc::ptr_eq(&grammar, curr_grammar));
-                            let parse_again = this.version.gt(&parsed_version) || grammar_changed;
+                            let parse_again =
+                                this.version.changed_since(&parsed_version) || grammar_changed;
                             this.parsing_in_background = false;
                             this.did_finish_parsing(new_tree, parsed_version, cx);
 
@@ -1080,12 +1081,12 @@ impl Buffer {
     }
 
     pub fn is_dirty(&self) -> bool {
-        !self.saved_version.ge(&self.version)
+        !self.saved_version.observed_all(&self.version)
             || self.file.as_ref().map_or(false, |file| file.is_deleted())
     }
 
     pub fn has_conflict(&self) -> bool {
-        !self.saved_version.ge(&self.version)
+        !self.saved_version.observed_all(&self.version)
             && self
                 .file
                 .as_ref()

crates/language/src/tests.rs

@@ -919,6 +919,10 @@ fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
         now += Duration::from_millis(rng.gen_range(0..=200));
         buffers.extend(new_buffer);
 
+        for buffer in &buffers {
+            buffer.read(cx).check_invariants();
+        }
+
         if mutation_count == 0 && network.is_idle() {
             break;
         }

crates/text/src/locator.rs

@@ -20,7 +20,7 @@ impl Locator {
     }
 
     pub fn from_index(ix: usize, count: usize) -> Self {
-        let id = ((ix as u128 * u64::MAX as u128) / count as u128) as u64;
+        let id = (1 + ix as u64) * (u64::MAX / (count as u64 + 2));
         Self(smallvec![id])
     }
 

crates/text/src/tests.rs

@@ -602,36 +602,3 @@ fn test_random_concurrent_edits(mut rng: StdRng) {
         buffer.check_invariants();
     }
 }
-
-impl Buffer {
-    fn check_invariants(&self) {
-        // Ensure every fragment is ordered by locator in the fragment tree and corresponds
-        // to an insertion fragment in the insertions tree.
-        let mut prev_fragment_id = Locator::min();
-        for fragment in self.snapshot.fragments.items(&None) {
-            assert!(fragment.id > prev_fragment_id);
-            prev_fragment_id = fragment.id.clone();
-
-            let insertion_fragment = self
-                .snapshot
-                .insertions
-                .get(
-                    &InsertionFragmentKey {
-                        timestamp: fragment.insertion_timestamp.local(),
-                        split_offset: fragment.insertion_offset,
-                    },
-                    &(),
-                )
-                .unwrap();
-            assert_eq!(insertion_fragment.fragment_id, fragment.id);
-        }
-
-        let mut cursor = self.snapshot.fragments.cursor::<Option<&Locator>>();
-        for insertion_fragment in self.snapshot.insertions.cursor::<()>() {
-            cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left, &None);
-            let fragment = cursor.item().unwrap();
-            assert_eq!(insertion_fragment.fragment_id, fragment.id);
-            assert_eq!(insertion_fragment.split_offset, fragment.insertion_offset);
-        }
-    }
-}

crates/text/src/text.rs

@@ -1125,8 +1125,8 @@ impl Buffer {
             false
         } else {
             match op {
-                Operation::Edit(edit) => self.version.ge(&edit.version),
+                Operation::Edit(edit) => self.version.observed_all(&edit.version),
-                Operation::Undo { undo, .. } => self.version.ge(&undo.version),
+                Operation::Undo { undo, .. } => self.version.observed_all(&undo.version),
             }
         }
     }
@@ -1244,6 +1244,47 @@ impl Buffer {
 
 #[cfg(any(test, feature = "test-support"))]
 impl Buffer {
+    pub fn check_invariants(&self) {
+        // Ensure every fragment is ordered by locator in the fragment tree and corresponds
+        // to an insertion fragment in the insertions tree.
+        let mut prev_fragment_id = Locator::min();
+        for fragment in self.snapshot.fragments.items(&None) {
+            assert!(fragment.id > prev_fragment_id);
+            prev_fragment_id = fragment.id.clone();
+
+            let insertion_fragment = self
+                .snapshot
+                .insertions
+                .get(
+                    &InsertionFragmentKey {
+                        timestamp: fragment.insertion_timestamp.local(),
+                        split_offset: fragment.insertion_offset,
+                    },
+                    &(),
+                )
+                .unwrap();
+            assert_eq!(insertion_fragment.fragment_id, fragment.id);
+        }
+
+        let mut cursor = self.snapshot.fragments.cursor::<Option<&Locator>>();
+        for insertion_fragment in self.snapshot.insertions.cursor::<()>() {
+            cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left, &None);
+            let fragment = cursor.item().unwrap();
+            assert_eq!(insertion_fragment.fragment_id, fragment.id);
+            assert_eq!(insertion_fragment.split_offset, fragment.insertion_offset);
+        }
+
+        let fragment_summary = self.snapshot.fragments.summary();
+        assert_eq!(
+            fragment_summary.text.visible,
+            self.snapshot.visible_text.len()
+        );
+        assert_eq!(
+            fragment_summary.text.deleted,
+            self.snapshot.deleted_text.len()
+        );
+    }
+
     pub fn set_group_interval(&mut self, group_interval: Duration) {
         self.history.group_interval = group_interval;
     }
@@ -1648,10 +1689,10 @@ impl BufferSnapshot {
         let fragments_cursor = if *since == self.version {
             None
         } else {
-            Some(
+            Some(self.fragments.filter(
-                self.fragments
+                move |summary| !since.observed_all(&summary.max_version),
-                    .filter(move |summary| !since.ge(&summary.max_version), &None),
+                &None,
-            )
+            ))
         };
         let mut cursor = self
             .fragments
@@ -2025,7 +2066,7 @@ impl<'a> sum_tree::Dimension<'a, FragmentSummary> for VersionedFullOffset {
     fn add_summary(&mut self, summary: &'a FragmentSummary, cx: &Option<clock::Global>) {
         if let Self::Offset(offset) = self {
             let version = cx.as_ref().unwrap();
-            if version.ge(&summary.max_insertion_version) {
+            if version.observed_all(&summary.max_insertion_version) {
                 *offset += summary.text.visible + summary.text.deleted;
             } else if version.observed_any(&summary.min_insertion_version) {
                 *self = Self::Invalid;