syntax: simplify alternations

This commit simplifies alternations by flattening them, similar
to how a recent commit flattened concatenations. Although, this is
simpler than concatenations, because we can't do anything with
literals.

Like concatenations, we only need to look one layer deep, since
this is applied inductively.

Author: BurntSushi

regex-syntax/src/hir/mod.rs

@@ -398,20 +398,29 @@ impl Hir {
     /// Returns the alternation of the given expressions.
     ///
     /// This flattens the alternation as appropriate.
-    pub fn alternation(mut exprs: Vec<Hir>) -> Hir {
-        if exprs.is_empty() {
-            return Hir::fail();
-        } else if exprs.len() == 1 {
-            return exprs.pop().unwrap();
-        }
-        match exprs.len() {
-            0 => Hir::empty(),
-            1 => exprs.pop().unwrap(),
-            _ => {
-                let props = Properties::alternation(&exprs);
-                Hir { kind: HirKind::Alternation(exprs), props }
+    pub fn alternation(hirs: Vec<Hir>) -> Hir {
+        // We rebuild the alternation by simplifying it. We proceed similarly
+        // as the concatenation case. But in this case, there's no literal
+        // simplification happening. We're just flattening alternations.
+        let mut new = vec![];
+        for hir in hirs {
+            let (kind, props) = hir.into_parts();
+            match kind {
+                HirKind::Alternation(hirs2) => {
+                    new.extend(hirs2);
+                }
+                kind => {
+                    new.push(Hir { kind, props });
+                }
             }
         }
+        if new.is_empty() {
+            return Hir::fail();
+        } else if new.len() == 1 {
+            return new.pop().unwrap();
+        }
+        let props = Properties::alternation(&new);
+        Hir { kind: HirKind::Alternation(new), props }
     }
 
     /// Returns an HIR expression for `.`.

regex-syntax/src/hir/translate.rs

@@ -3335,4 +3335,24 @@ mod tests {
             ])
         );
     }
+
+    // This tests that the smart Hir::alternation constructor simplifies the
+    // given exprs in a way we expect.
+    #[test]
+    fn smart_alternation() {
+        assert_eq!(
+            t("(?:foo)|(?:bar)"),
+            hir_alt(vec![hir_lit("foo"), hir_lit("bar")])
+        );
+        assert_eq!(
+            t("quux|(?:abc|def|xyz)|baz"),
+            hir_alt(vec![
+                hir_lit("quux"),
+                hir_lit("abc"),
+                hir_lit("def"),
+                hir_lit("xyz"),
+                hir_lit("baz"),
+            ])
+        );
+    }
 }