perf: Avoid re-canonicalizing the entire IntervalSet on push

Canonicalize is taking up a significant amount due to a regex with a huge amount of character ranges (generated by [lalrpop](https://github.com/lalrpop/lalrpop)'s lexer expanding multiple `\w` in a token). While this could perhaps be fixed in lalrpop I did notice the TODO in the code and after addressing this so we automatically union and compress on each push instead of re-canonicalizing on every push and that fixed the performance problem.

I did see the earlier attempt at this rust-lang#1051 and it seems like that was reverted and regression tests were added so I hope that and the existing tests are enough (I don't have a clear idea on what tests might be missing).

Author: Marwes

regex-syntax/src/hir/interval.rs

@@ -80,15 +80,44 @@ impl<I: Interval> IntervalSet<I> {
     }
 
     /// Add a new interval to this set.
-    pub fn push(&mut self, interval: I) {
-        // TODO: This could be faster. e.g., Push the interval such that
-        // it preserves canonicalization.
-        self.ranges.push(interval);
-        self.canonicalize();
-        // We don't know whether the new interval added here is considered
-        // case folded, so we conservatively assume that the entire set is
-        // no longer case folded if it was previously.
-        self.folded = false;
+    pub fn push(&mut self, mut interval: I) {
+        match self.ranges.binary_search(&interval) {
+            // Interval is an exact duplicate of one that exists
+            Ok(_) => {}
+            Err(i) => {
+                // The search finds us the first index where the previous interval start is less
+                // than the new interval start. Since the existing intervals are non-overlapping
+                // we only need to try to union this single preceding interval
+                let mut start = i;
+                if let Some(before_i) = i.checked_sub(1) {
+                    let before = &self.ranges[before_i];
+                    if let Some(union) = before.union(&interval) {
+                        interval = union;
+                        start = before_i;
+                    }
+                }
+                // `interval` may overlap with any number of intervals following the insertion
+                // point so we need to try to union with all of them until we reach the first
+                // non-overlapping interval
+                let mut end = i;
+                for after_i in i..self.ranges.len() {
+                    let after = &self.ranges[after_i];
+                    if let Some(union) = interval.union(after) {
+                        interval = union;
+                        end = after_i + 1;
+                    } else {
+                        break;
+                    }
+                }
+
+                self.ranges.splice(start..end, core::iter::once(interval));
+
+                // We don't know whether the new interval added here is considered
+                // case folded, so we conservatively assume that the entire set is
+                // no longer case folded if it was previously.
+                self.folded = false;
+            }
+        }
     }
 
     /// Return an iterator over all intervals in this set.