Fix cli tool and AST->HIR translation

Author: Multimodcrafter

regex-cli/cmd/generate/fowler.rs

@@ -421,6 +421,5 @@ fn count_capturing_groups_ast(ast: &regex_syntax::ast::Ast) -> usize {
         Ast::Concat(ref concat) => {
             concat.asts.iter().map(count_capturing_groups_ast).sum()
         }
-        Ast::LookAround(_) => todo!(),
     }
 }

regex-syntax/src/hir/translate.rs

@@ -212,6 +212,13 @@ enum HirFrame {
     /// This sentinel only exists to stop other things (like flattening
     /// literals) from reaching across repetition operators.
     Repetition,
+    /// This is pushed whenever a look-around expression is observed. After
+    /// visiting the sub-expression in the look-around, the translator's stack
+    /// is expected to have this sentinel at the top.
+    ///
+    /// This sentinel only exists to stop other things (like flattening
+    /// literals) from reaching across look-around operators.
+    LookAround,
     /// This is pushed on to the stack upon first seeing any kind of capture,
     /// indicated by parentheses (including non-capturing groups). It is popped
     /// upon leaving a group.
@@ -298,6 +305,18 @@ impl HirFrame {
         }
     }
 
+    fn unwrap_lookaround(self) {
+        match self {
+            HirFrame::LookAround => {}
+            _ => {
+                panic!(
+                    "tried to unwrap look-around from HirFrame, got: {:?}",
+                    self
+                )
+            }
+        }
+    }
+
     /// Assert that the current stack frame is a group indicator and return
     /// its corresponding flags (the flags that were active at the time the
     /// group was entered).
@@ -363,6 +382,7 @@ impl<'t, 'p> Visitor for TranslatorI<'t, 'p> {
                     self.push(HirFrame::AlternationBranch);
                 }
             }
+            Ast::LookAround(_) => self.push(HirFrame::LookAround),
             _ => {}
         }
         Ok(())
@@ -448,6 +468,7 @@ impl<'t, 'p> Visitor for TranslatorI<'t, 'p> {
             }
             Ast::LookAround(ref x) => {
                 let expr = Box::new(self.pop().unwrap().unwrap_expr());
+                self.pop().unwrap().unwrap_lookaround();
                 self.push(HirFrame::Expr(Hir::lookaround(match x.kind {
                     ast::LookAroundKind::PositiveLookBehind => {
                         hir::LookAround::PositiveLookBehind(expr)
@@ -770,6 +791,9 @@ impl<'t, 'p> TranslatorI<'t, 'p> {
             HirFrame::AlternationBranch => {
                 unreachable!("expected expr or concat, got alt branch marker")
             }
+            HirFrame::LookAround => {
+                unreachable!("expected expr or concat, got look-around")
+            }
         }
     }
 
@@ -801,6 +825,9 @@ impl<'t, 'p> TranslatorI<'t, 'p> {
             HirFrame::AlternationBranch => {
                 unreachable!("expected expr or alt, got alt branch marker")
             }
+            HirFrame::LookAround => {
+                unreachable!("expected expr or alt, got look-around")
+            }
         }
     }
 
@@ -1612,6 +1639,15 @@ mod tests {
         Hir::look(look)
     }
 
+    fn hir_lookbehind(expr: Hir, positive: bool) -> Hir {
+        let lookaround = if positive {
+            hir::LookAround::PositiveLookBehind(Box::new(expr))
+        } else {
+            hir::LookAround::NegativeLookBehind(Box::new(expr))
+        };
+        Hir::lookaround(lookaround)
+    }
+
     #[test]
     fn empty() {
         assert_eq!(t(""), Hir::empty());
@@ -1835,6 +1871,44 @@ mod tests {
         assert_eq!(t(r"(?-u)\B"), hir_look(hir::Look::WordAsciiNegate));
     }
 
+    #[test]
+    fn lookarounds() {
+        assert_eq!(t("(?<=a)"), hir_lookbehind(hir_lit("a"), true));
+        assert_eq!(t("(?<!a)"), hir_lookbehind(hir_lit("a"), false));
+        assert_eq!(t("(?<!)"), hir_lookbehind(Hir::empty(), false));
+        assert_eq!(
+            t("(?<=a|b)"),
+            hir_lookbehind(hir_alt(vec![hir_lit("a"), hir_lit("b")]), true)
+        );
+        assert_eq!(
+            t("(?<=a)|(?<!b)"),
+            hir_alt(vec![
+                hir_lookbehind(hir_lit("a"), true),
+                hir_lookbehind(hir_lit("b"), false)
+            ])
+        );
+        assert_eq!(
+            t("(?<=a)(?<!b)"),
+            hir_cat(vec![
+                hir_lookbehind(hir_lit("a"), true),
+                hir_lookbehind(hir_lit("b"), false)
+            ])
+        );
+        assert_eq!(
+            t("a(?<=ba(?<!c))"),
+            hir_cat(vec![
+                hir_lit("a"),
+                hir_lookbehind(
+                    hir_cat(vec![
+                        hir_lit("ba"),
+                        hir_lookbehind(hir_lit("c"), false)
+                    ]),
+                    true
+                )
+            ])
+        );
+    }
+
     #[test]
     fn group() {
         assert_eq!(t("(a)"), hir_capture(1, hir_lit("a")));