retain descending span end order during partioning

Author: pascalkuthe

helix-core/src/syntax/span.rs

@@ -107,11 +107,9 @@ impl SpanIter {
     ///
     /// * intersect: the end of span `A`   
     fn partition_spans_at(&mut self, intersect: usize) {
-        let first_partitioned_span = self.spans[self.index];
-
         let mut i = self.index;
         while let Some(span) = self.spans.get_mut(i) {
-            if span.start != self.cursor || span.end < intersect {
+            if span.start != self.cursor || span.end <= intersect {
                 break;
             }
 
@@ -123,30 +121,23 @@ impl SpanIter {
             i += 1;
         }
 
-        let num_partitioned_spans = i - self.index;
-
         // When spans are partioned, the span Vec may need to be re-sorted
         // because the `span.start` may now be greater than some `span.start`
         // later in the Vec. This is not a classic "sort": we take several
         // shortcuts to improve the runtime so that the sort may be done in
         // time linear to the cardinality of the span Vec. Practically speaking
         // the runtime is even better since we only scan from `self.index` to
         // the first element of the Vec with a `span.start` after this span.
-        let intersect_span = Span {
-            start: intersect,
-            ..first_partitioned_span
-        };
-
         let num_spans_to_resort = self.spans[i..]
             .iter()
-            .take_while(|&&span| span <= intersect_span)
+            .take_while(|&&span| span.start <= intersect)
             .count();
 
         // Rotate the subsliced spans so that they come after the spans that
         // have smaller `span.start`s.
         if num_spans_to_resort != 0 {
             let first_sorted_span = i + num_spans_to_resort;
-            self.spans[self.index..first_sorted_span].rotate_left(num_partitioned_spans);
+            self.spans[self.index..first_sorted_span].sort_unstable();
         }
     }
 }

helix-core/src/syntax/span/test.rs

@@ -111,8 +111,8 @@ fn test_many_overlapping_span_iter_events() {
             Source { start: 12, end: 13 },
             HighlightEnd, // ends 4
             HighlightEnd, // ends 3
-            HighlightStart(Highlight(5)),
             HighlightStart(Highlight(4)),
+            HighlightStart(Highlight(5)),
             Source { start: 13, end: 15 },
             HighlightEnd, // ends 5
             HighlightEnd, // ends 4

helix-core/src/syntax/test.rs

@@ -642,8 +642,11 @@ fn span(file_size: usize, allow_empty: bool, scope: usize) -> impl Strategy<Valu
         })
 }
 
-const MAX_SPAN_LIST_SIZE: usize = 20;
-const MAX_FILE_SIZE: usize = 40;
+/// The maximum number of created spans.
+/// Must not surpass 128 because `HighlightSet` can not represent more elements
+/// When trying to reduce a regression it is often useful to reduce this significantly
+const MAX_SPAN_LIST_SIZE: usize = 128;
+const MAX_FILE_SIZE: usize = 200;
 
 fn span_list() -> impl Strategy<Value = Vec<Span>> + Clone {
     let file_size = 1..MAX_FILE_SIZE;