feat: validate lookbehind in Java

Author: Aloso

pomsky-lib/afl-fuzz/src/main.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use arbitrary::{Arbitrary, Unstructured};
-use pomsky::{options::RegexFlavor, Expr};
+use pomsky::{Expr, options::RegexFlavor};
 use regex::RegexSet;
 use regex_test::{Outcome, RegexTest};
 
@@ -82,11 +82,11 @@ fn check(
     };
     if let Outcome::Error(e) = outcome {
         let e = e.trim();
-        if let Some(ignored_errors) = ignored_errors.get(&flavor) {
-            if ignored_errors.is_match(e) {
-                debug!(f, " {regex:?} ({flavor:?}) ERROR IGNORED: {e}");
-                return;
-            }
+        if let Some(ignored_errors) = ignored_errors.get(&flavor)
+            && ignored_errors.is_match(e)
+        {
+            debug!(f, " {regex:?} ({flavor:?}) ERROR IGNORED: {e}");
+            return;
         }
 
         debug!(ef, "\n{expr:?}\n{flavor:?}|{regex:?}|{e}\n");

pomsky-lib/src/diagnose/compile_error.rs

@@ -216,10 +216,10 @@ impl core::fmt::Display for CompileErrorKind {
                 )
             }
             CompileErrorKind::LookbehindNotConstantLength { flavor } => match flavor {
-                RegexFlavor::Pcre | RegexFlavor::Python => write!(
+                RegexFlavor::Pcre | RegexFlavor::Python | RegexFlavor::Java => write!(
                     f,
                     "In the {flavor:?} flavor, lookbehinds must have a {} length",
-                    if flavor == &RegexFlavor::Pcre { "bounded" } else { "constant" }
+                    if flavor == &RegexFlavor::Python { "constant" } else { "bounded" }
                 ),
                 _ => write!(f, "This kind of lookbehind is not supported in the {flavor:?} flavor"),
             },

pomsky-lib/src/exprs/lookaround.rs

@@ -60,7 +60,9 @@ impl RegexLookaround {
                 RegexFlavor::Pcre => {
                     content.validate_in_lookbehind_pcre()?;
                 }
-                // TODO: Java, see <https://github.com/pomsky-lang/pomsky/issues/69>
+                RegexFlavor::Java => {
+                    content.validate_in_lookbehind_java()?;
+                }
                 _ => {}
             }
         }

pomsky-lib/src/exprs/mod.rs

@@ -91,11 +91,11 @@ impl Expr {
             Ok(compiled) => compiled,
             Err(e) => return (None, vec![e.diagnostic(input)]),
         };
-        if let Some(rec_span) = validator.first_recursion {
-            if !compiled.terminates() {
-                let error = CompileErrorKind::InfiniteRecursion.at(rec_span);
-                return (None, vec![error.diagnostic(input)]);
-            }
+        if let Some(rec_span) = validator.first_recursion
+            && !compiled.terminates()
+        {
+            let error = CompileErrorKind::InfiniteRecursion.at(rec_span);
+            return (None, vec![error.diagnostic(input)]);
         }
         let count = compiled.optimize();
 

pomsky-lib/src/regex/mod.rs

@@ -149,6 +149,38 @@ impl Regex {
         }
     }
 
+    pub(super) fn validate_in_lookbehind_java(&self) -> Result<(), CompileErrorKind> {
+        match self {
+            Regex::Group(g) => {
+                for part in &g.parts {
+                    part.validate_in_lookbehind_java()?;
+                }
+                Ok(())
+            }
+            Regex::Alternation(alt) => {
+                for part in &alt.parts {
+                    part.validate_in_lookbehind_java()?;
+                }
+                Ok(())
+            }
+            Regex::Repetition(r) => match r.kind.upper_bound {
+                Some(_) => Ok(()),
+                _ => {
+                    Err(CompileErrorKind::LookbehindNotConstantLength { flavor: RegexFlavor::Java })
+                }
+            },
+            Regex::Grapheme => Err(CompileErrorKind::UnsupportedInLookbehind {
+                flavor: RegexFlavor::Java,
+                feature: Feature::Grapheme,
+            }),
+            Regex::Reference(_) => Err(CompileErrorKind::UnsupportedInLookbehind {
+                flavor: RegexFlavor::Java,
+                feature: Feature::Backreference,
+            }),
+            _ => Ok(()),
+        }
+    }
+
     pub(super) fn is_single_char(&self) -> bool {
         if let Regex::Literal(l) = self {
             !l.is_empty() && l.chars().nth(1).is_none()