redirct: flex partialOrd and itertools to allocate less space during union

Author: Moritz Vetter

Cargo.lock

@@ -10,4 +10,5 @@ rust-version = "1.57"
 doctest = false
 
 [dependencies]
+itertools = "0.10.0"
 text-size = "1.0.0"

crates/text_edit/Cargo.toml

@@ -4,6 +4,8 @@
 //! so `TextEdit` is the ultimate representation of the work done by
 //! rust-analyzer.
 
+use itertools::Itertools;
+use std::cmp::Ordering;
 pub use text_size::{TextRange, TextSize};
 
 /// `InsertDelete` -- a single "atomic" change to text
@@ -16,6 +18,22 @@ pub struct Indel {
     pub delete: TextRange,
 }
 
+impl PartialOrd for Indel {
+    fn partial_cmp(&self, other: &Indel) -> Option<Ordering> {
+        if self == other {
+            return Some(Ordering::Equal);
+        }
+        let cmp_to_other = self.delete.end() <= other.delete.start();
+        let cmp_to_self = other.delete.end() <= self.delete.start();
+        match (cmp_to_other, cmp_to_self) {
+            (true, true) => Some(Ordering::Equal),
+            (true, false) => Some(Ordering::Less),
+            (false, true) => Some(Ordering::Greater),
+            (false, false) => None,
+        }
+    }
+}
+
 #[derive(Default, Debug, Clone)]
 pub struct TextEdit {
     /// Invariant: disjoint and sorted by `delete`.
@@ -109,9 +127,8 @@ impl TextEdit {
     }
 
     pub fn union(&mut self, other: TextEdit) -> Result<(), TextEdit> {
-        // FIXME: can be done without allocating intermediate vector
-        let mut all = self.iter().chain(other.iter()).collect::<Vec<_>>();
-        if !check_disjoint_and_sort(&mut all) {
+        let mut iter_merge = self.iter().merge(other.iter());
+        if !check_disjoint(&mut iter_merge) {
             return Err(other);
         }
 
@@ -185,17 +202,28 @@ impl TextEditBuilder {
     }
 }
 
-fn assert_disjoint_or_equal(indels: &mut [Indel]) {
+fn assert_disjoint_or_equal(indels: &mut Vec<Indel>) {
     assert!(check_disjoint_and_sort(indels));
 }
-// FIXME: Remove the impl Bound here, it shouldn't be needed
-fn check_disjoint_and_sort(indels: &mut [impl std::borrow::Borrow<Indel>]) -> bool {
-    indels.sort_by_key(|indel| (indel.borrow().delete.start(), indel.borrow().delete.end()));
-    indels.iter().zip(indels.iter().skip(1)).all(|(l, r)| {
-        let l = l.borrow();
-        let r = r.borrow();
-        l.delete.end() <= r.delete.start() || l == r
-    })
+
+fn check_disjoint_and_sort(indels: &mut Vec<Indel>) -> bool {
+    indels.sort_by_key(|indel| (indel.delete.start(), indel.delete.end()));
+    return check_disjoint(&mut indels.iter());
+}
+
+fn check_disjoint<'a, I>(indels: &mut I) -> bool
+where
+    I: std::iter::Iterator<Item = &'a Indel>,
+{
+    if let Some(indel) = indels.next() {
+        let mut indel = indel;
+        return indels.all(|right_indel| {
+            let check = indel <= right_indel;
+            indel = right_indel;
+            return check;
+        });
+    }
+    true
 }
 
 #[cfg(test)]