Add lookaround expressions to HIR

This is the first step to supporting captureless lookbehind assertions

Author: Multimodcrafter

regex-automata/src/meta/reverse_inner.rs

@@ -170,6 +170,7 @@ fn top_concat(mut hir: &Hir) -> Option<Vec<Hir>> {
             | HirKind::Literal(_)
             | HirKind::Class(_)
             | HirKind::Look(_)
+            | HirKind::Lookaround(_)
             | HirKind::Repetition(_)
             | HirKind::Alternation(_) => return None,
             HirKind::Capture(hir::Capture { ref sub, .. }) => sub,
@@ -206,6 +207,7 @@ 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::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-automata/src/nfa/thompson/compiler.rs

@@ -1003,6 +1003,7 @@ impl Compiler {
             Class(Class::Bytes(ref c)) => self.c_byte_class(c),
             Class(Class::Unicode(ref c)) => self.c_unicode_class(c),
             Look(ref look) => self.c_look(look),
+            Lookaround(_) => todo!("implement lookaround NFA compilation"),
             Repetition(ref rep) => self.c_repetition(rep),
             Capture(ref c) => self.c_cap(c.index, c.name.as_deref(), &c.sub),
             Concat(ref es) => self.c_concat(es.iter().map(|e| self.c(e))),

regex-syntax/src/hir/literal.rs

@@ -172,7 +172,9 @@ impl Extractor {
         use crate::hir::HirKind::*;
 
         match *hir.kind() {
-            Empty | Look(_) => Seq::singleton(self::Literal::exact(vec![])),
+            Empty | Look(_) | Lookaround(_) => {
+                Seq::singleton(self::Literal::exact(vec![]))
+            }
             Literal(hir::Literal(ref bytes)) => {
                 let mut seq =
                     Seq::singleton(self::Literal::exact(bytes.to_vec()));

regex-syntax/src/hir/mod.rs

@@ -373,6 +373,13 @@ impl Hir {
         Hir { kind: HirKind::Look(look), props }
     }
 
+    /// Creates a look-around subexpression HIR expression.
+    #[inline]
+    pub fn lookaround(lookaround: Lookaround) -> Hir {
+        let props = Properties::lookaround(&lookaround);
+        Hir { kind: HirKind::Lookaround(lookaround), props }
+    }
+
     /// Creates a repetition HIR expression.
     #[inline]
     pub fn repetition(mut rep: Repetition) -> Hir {
@@ -728,6 +735,8 @@ pub enum HirKind {
     Class(Class),
     /// A look-around assertion. A look-around match always has zero length.
     Look(Look),
+    /// A look-around subexpression
+    Lookaround(Lookaround),
     /// A repetition operation applied to a sub-expression.
     Repetition(Repetition),
     /// A capturing group, which contains a sub-expression.
@@ -761,6 +770,7 @@ impl HirKind {
             | HirKind::Literal(_)
             | HirKind::Class(_)
             | HirKind::Look(_) => &[],
+            HirKind::Lookaround(ref lookaround) => from_ref(lookaround.sub()),
             HirKind::Repetition(Repetition { ref sub, .. }) => from_ref(sub),
             HirKind::Capture(Capture { ref sub, .. }) => from_ref(sub),
             HirKind::Concat(ref subs) => subs,
@@ -1786,6 +1796,37 @@ impl Look {
     }
 }
 
+/// 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
+    PositiveLookBehind(Box<Hir>),
+    /// A negative lookbehind assertion
+    NegativeLookBehind(Box<Hir>),
+}
+
+impl Lookaround {
+    /// Returns a reference to the inner expression that must match for this
+    /// lookaround assertion to hold.
+    pub fn sub(&self) -> &Hir {
+        match self {
+            Lookaround::PositiveLookBehind(sub)
+            | Lookaround::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,
+        }
+    }
+}
+
 /// The high-level intermediate representation for a capturing group.
 ///
 /// A capturing group always has an index and a child expression. It may
@@ -1935,6 +1976,9 @@ impl Drop for Hir {
                 | HirKind::Literal(_)
                 | HirKind::Class(_)
                 | HirKind::Look(_) => {}
+                HirKind::Lookaround(ref mut x) => {
+                    stack.push(mem::replace(x.sub_mut(), Hir::empty()));
+                }
                 HirKind::Capture(ref mut x) => {
                     stack.push(mem::replace(&mut x.sub, Hir::empty()));
                 }
@@ -2499,6 +2543,18 @@ impl Properties {
         Properties(Box::new(inner))
     }
 
+    fn lookaround(lookaround: &Lookaround) -> Properties {
+        let sub_p = lookaround.sub().properties();
+        let inner = PropertiesI {
+            minimum_len: Some(0),
+            maximum_len: Some(0),
+            literal: false,
+            alternation_literal: false,
+            ..*sub_p.0.clone()
+        };
+        Properties(Box::new(inner))
+    }
+
     /// Create a new set of HIR properties for a repetition.
     fn repetition(rep: &Repetition) -> Properties {
         let p = rep.sub.properties();

regex-syntax/src/hir/print.rs

@@ -227,6 +227,12 @@ impl<W: fmt::Write> Visitor for Writer<W> {
                     self.wtr.write_str(r"\b{end-half}")?;
                 }
             },
+            HirKind::Lookaround(hir::Lookaround::PositiveLookBehind(_)) => {
+                self.wtr.write_str(r"(?<=)")?;
+            }
+            HirKind::Lookaround(hir::Lookaround::NegativeLookBehind(_)) => {
+                self.wtr.write_str(r"(?<!)")?;
+            }
             HirKind::Capture(hir::Capture { ref name, .. }) => {
                 self.wtr.write_str("(")?;
                 if let Some(ref name) = *name {
@@ -293,7 +299,8 @@ impl<W: fmt::Write> Visitor for Writer<W> {
             }
             HirKind::Capture(_)
             | HirKind::Concat(_)
-            | HirKind::Alternation(_) => {
+            | HirKind::Alternation(_)
+            | HirKind::Lookaround(_) => {
                 self.wtr.write_str(r")")?;
             }
         }