Change how flatten works on hir::Lookaround

The lack of recursing into the inner expression of a lookaround is correct under the current assumption that lookarounds cannot have capture groups. But once the restriction is lifted, this wrong implementation can be very subtle to find. Instead, we can already do the filtering and accept it being a no-op for now.

Author: shilangyu

regex-automata/src/meta/reverse_inner.rs

@@ -207,7 +207,9 @@ fn flatten(hir: &Hir) -> Hir {
         HirKind::Literal(hir::Literal(ref x)) => Hir::literal(x.clone()),
         HirKind::Class(ref x) => Hir::class(x.clone()),
         HirKind::Look(ref x) => Hir::look(x.clone()),
-        HirKind::Lookaround(ref x) => Hir::lookaround(x.clone()),
+        HirKind::Lookaround(ref x) => {
+            Hir::lookaround(x.with(flatten(x.sub())))
+        }
         HirKind::Repetition(ref x) => Hir::repetition(x.with(flatten(&x.sub))),
         // This is the interesting case. We just drop the group information
         // entirely and use the child HIR itself.

regex-syntax/src/hir/mod.rs

@@ -1796,15 +1796,15 @@ impl Look {
     }
 }
 
-/// Represents a general lookaround assertion
+/// Represents a general lookaround assertion.
 ///
 /// Currently, only lookbehind assertions are supported.
 /// Furthermore, capture groups inside assertions are not supported.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Lookaround {
-    /// A positive lookbehind assertion
+    /// A positive lookbehind assertion.
     PositiveLookBehind(Box<Hir>),
-    /// A negative lookbehind assertion
+    /// A negative lookbehind assertion.
     NegativeLookBehind(Box<Hir>),
 }
 
@@ -1813,16 +1813,31 @@ impl Lookaround {
     /// lookaround assertion to hold.
     pub fn sub(&self) -> &Hir {
         match self {
-            Lookaround::PositiveLookBehind(sub)
-            | Lookaround::NegativeLookBehind(sub) => sub,
+            Self::PositiveLookBehind(sub) | Self::NegativeLookBehind(sub) => {
+                sub
+            }
         }
     }
 
     /// Returns a mutable reference to the inner expression
     pub fn sub_mut(&mut self) -> &mut Hir {
         match self {
-            Lookaround::PositiveLookBehind(sub)
-            | Lookaround::NegativeLookBehind(sub) => sub,
+            Self::PositiveLookBehind(sub) | Self::NegativeLookBehind(sub) => {
+                sub
+            }
+        }
+    }
+
+    /// Returns a new lookaround of the same kind, but with its
+    /// sub-expression replaced with the one given.
+    pub fn with(&self, sub: Hir) -> Lookaround {
+        match self {
+            Self::PositiveLookBehind(_) => {
+                Self::PositiveLookBehind(Box::new(sub))
+            }
+            Self::NegativeLookBehind(_) => {
+                Self::NegativeLookBehind(Box::new(sub))
+            }
         }
     }
 }