Add LookAround to Ast

Author: shilangyu

regex-syntax/src/ast/mod.rs

@@ -479,6 +479,8 @@ pub enum Ast {
     Dot(Box<Span>),
     /// A single zero-width assertion.
     Assertion(Box<Assertion>),
+    /// A single look-around regular expression.
+    LookAround(Box<LookAround>),
     /// A single Unicode character class, e.g., `\pL` or `\p{Greek}`.
     ClassUnicode(Box<ClassUnicode>),
     /// A single perl character class, e.g., `\d` or `\W`.
@@ -523,6 +525,11 @@ impl Ast {
         Ast::Assertion(Box::new(e))
     }
 
+    /// Create a "look-around" AST item.
+    pub fn look_around(e: LookAround) -> Ast {
+        Ast::LookAround(Box::new(e))
+    }
+
     /// Create a "Unicode class" AST item.
     pub fn class_unicode(e: ClassUnicode) -> Ast {
         Ast::ClassUnicode(Box::new(e))
@@ -566,6 +573,7 @@ impl Ast {
             Ast::Literal(ref x) => &x.span,
             Ast::Dot(ref span) => span,
             Ast::Assertion(ref x) => &x.span,
+            Ast::LookAround(ref x) => &x.span,
             Ast::ClassUnicode(ref x) => &x.span,
             Ast::ClassPerl(ref x) => &x.span,
             Ast::ClassBracketed(ref x) => &x.span,
@@ -598,6 +606,7 @@ impl Ast {
             Ast::ClassBracketed(_)
             | Ast::Repetition(_)
             | Ast::Group(_)
+            | Ast::LookAround(_)
             | Ast::Alternation(_)
             | Ast::Concat(_) => true,
         }
@@ -1344,6 +1353,28 @@ pub enum AssertionKind {
     WordBoundaryEndHalf,
 }
 
+/// A single zero-width look-around.
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+pub struct LookAround {
+    /// The span of this look-around.
+    pub span: Span,
+    /// The look-around kind, e.g. negative/positive look-behind.
+    pub kind: LookAroundKind,
+    /// The regular expression inside the look-around.
+    pub ast: Box<Ast>,
+}
+
+/// A look-around kind.
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+pub enum LookAroundKind {
+    /// `(?<=...)`
+    PositiveLookBehind,
+    /// `(?<!...)`
+    NegativeLookBehind,
+}
+
 /// A repetition operation applied to a regular expression.
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
@@ -1649,6 +1680,7 @@ impl Drop for Ast {
             | Ast::ClassBracketed(_) => return,
             Ast::Repetition(ref x) if !x.ast.has_subexprs() => return,
             Ast::Group(ref x) if !x.ast.has_subexprs() => return,
+            Ast::LookAround(ref x) if !x.ast.has_subexprs() => return,
             Ast::Alternation(ref x) if x.asts.is_empty() => return,
             Ast::Concat(ref x) if x.asts.is_empty() => return,
             _ => {}
@@ -1675,6 +1707,9 @@ impl Drop for Ast {
                 Ast::Group(ref mut x) => {
                     stack.push(mem::replace(&mut x.ast, empty_ast()));
                 }
+                Ast::LookAround(ref mut x) => {
+                    stack.push(mem::replace(&mut x.ast, empty_ast()));
+                }
                 Ast::Alternation(ref mut x) => {
                     stack.extend(x.asts.drain(..));
                 }

regex-syntax/src/ast/parse.rs

@@ -2328,6 +2328,7 @@ impl<'p, 's, P: Borrow<Parser>> ast::Visitor for NestLimiter<'p, 's, P> {
             Ast::ClassBracketed(ref x) => &x.span,
             Ast::Repetition(ref x) => &x.span,
             Ast::Group(ref x) => &x.span,
+            Ast::LookAround(ref x) => &x.span,
             Ast::Alternation(ref x) => &x.span,
             Ast::Concat(ref x) => &x.span,
         };
@@ -2349,6 +2350,7 @@ impl<'p, 's, P: Borrow<Parser>> ast::Visitor for NestLimiter<'p, 's, P> {
             Ast::ClassBracketed(_)
             | Ast::Repetition(_)
             | Ast::Group(_)
+            | Ast::LookAround(_)
             | Ast::Alternation(_)
             | Ast::Concat(_) => {
                 self.decrement_depth();
@@ -3753,6 +3755,11 @@ bar
         );
     }
 
+    #[test]
+    fn parse_lookbehinds() {
+        todo!()
+    }
+
     #[test]
     fn parse_unsupported_capture_in_lookbehind() {
         assert_eq!(

regex-syntax/src/ast/print.rs

@@ -80,6 +80,7 @@ impl<W: fmt::Write> Visitor for Writer<W> {
     fn visit_pre(&mut self, ast: &Ast) -> fmt::Result {
         match *ast {
             Ast::Group(ref x) => self.fmt_group_pre(x),
+            Ast::LookAround(ref x) => self.fmt_lookaround_pre(x),
             Ast::ClassBracketed(ref x) => self.fmt_class_bracketed_pre(x),
             _ => Ok(()),
         }
@@ -92,6 +93,7 @@ impl<W: fmt::Write> Visitor for Writer<W> {
             Ast::Literal(ref x) => self.fmt_literal(x),
             Ast::Dot(_) => self.wtr.write_str("."),
             Ast::Assertion(ref x) => self.fmt_assertion(x),
+            Ast::LookAround(ref x) => self.fmt_lookaround_post(x),
             Ast::ClassPerl(ref x) => self.fmt_class_perl(x),
             Ast::ClassUnicode(ref x) => self.fmt_class_unicode(x),
             Ast::ClassBracketed(ref x) => self.fmt_class_bracketed_post(x),
@@ -174,6 +176,18 @@ impl<W: fmt::Write> Writer<W> {
         self.wtr.write_str(")")
     }
 
+    fn fmt_lookaround_pre(&mut self, ast: &ast::LookAround) -> fmt::Result {
+        use crate::ast::LookAroundKind::*;
+        match ast.kind {
+            PositiveLookBehind => self.wtr.write_str("(?<="),
+            NegativeLookBehind => self.wtr.write_str("(?<!"),
+        }
+    }
+
+    fn fmt_lookaround_post(&mut self, _ast: &ast::LookAround) -> fmt::Result {
+        self.wtr.write_str(")")
+    }
+
     fn fmt_repetition(&mut self, ast: &ast::Repetition) -> fmt::Result {
         use crate::ast::RepetitionKind::*;
         match ast.op.kind {
@@ -511,6 +525,12 @@ mod tests {
         roundtrip("(a)");
     }
 
+    #[test]
+    fn print_lookaround() {
+        roundtrip("(?<a)");
+        roundtrip("(?<!a)");
+    }
+
     #[test]
     fn print_class() {
         roundtrip(r"[abc]");

regex-syntax/src/ast/visitor.rs

@@ -140,6 +140,9 @@ enum Frame<'a> {
     /// A stack frame allocated just before descending into a group's child
     /// node.
     Group(&'a ast::Group),
+    /// A stack frame allocated just before descending into a look-around's
+    /// child node.
+    LookAround(&'a ast::LookAround),
     /// The stack frame used while visiting every child node of a concatenation
     /// of expressions.
     Concat {
@@ -270,6 +273,7 @@ impl<'a> HeapVisitor<'a> {
             }
             Ast::Repetition(ref x) => Some(Frame::Repetition(x)),
             Ast::Group(ref x) => Some(Frame::Group(x)),
+            Ast::LookAround(ref x) => Some(Frame::LookAround(x)),
             Ast::Concat(ref x) if x.asts.is_empty() => None,
             Ast::Concat(ref x) => {
                 Some(Frame::Concat { head: &x.asts[0], tail: &x.asts[1..] })
@@ -289,6 +293,7 @@ impl<'a> HeapVisitor<'a> {
         match induct {
             Frame::Repetition(_) => None,
             Frame::Group(_) => None,
+            Frame::LookAround(_) => None,
             Frame::Concat { tail, .. } => {
                 if tail.is_empty() {
                     None
@@ -444,6 +449,7 @@ impl<'a> Frame<'a> {
         match *self {
             Frame::Repetition(rep) => &rep.ast,
             Frame::Group(group) => &group.ast,
+            Frame::LookAround(look) => &look.ast,
             Frame::Concat { head, .. } => head,
             Frame::Alternation { head, .. } => head,
         }

regex-syntax/src/hir/translate.rs

@@ -354,6 +354,9 @@ impl<'t, 'p> Visitor for TranslatorI<'t, 'p> {
                     .unwrap_or_else(|| self.flags());
                 self.push(HirFrame::Group { old_flags });
             }
+            Ast::LookAround(ref x) => {
+                todo!("translation from AST to HIR");
+            }
             Ast::Concat(_) => {
                 self.push(HirFrame::Concat);
             }
@@ -446,6 +449,9 @@ impl<'t, 'p> Visitor for TranslatorI<'t, 'p> {
                 self.trans().flags.set(old_flags);
                 self.push(HirFrame::Expr(self.hir_capture(x, expr)));
             }
+            Ast::LookAround(_) => {
+                todo!("translation from AST to HIR");
+            }
             Ast::Concat(_) => {
                 let mut exprs = vec![];
                 while let Some(expr) = self.pop_concat_expr() {