Address feedback and fix mismatched parentheses in the test

Tighten cases where new groups slipped through the existing guards. Add a regression test.

Signed-off-by: Igor Peshansky <ipeshansky@nvidia.com>

Author: igorpeshansky

sql-plugin/src/main/scala/com/nvidia/spark/rapids/RegexParser.scala

@@ -2057,7 +2057,9 @@ object RegexRewrite {
   @scala.annotation.tailrec
   private def removeBrackets(astLs: collection.Seq[RegexAST]): collection.Seq[RegexAST] = {
     astLs match {
-      case collection.Seq(RegexGroup(_, RegexSequence(terms))) => removeBrackets(terms)
+      case collection.Seq(RegexGroup(
+        RegexGroup.Capturing | RegexGroup.NonCapturing,
+        RegexSequence(terms))) => removeBrackets(terms)
       case _ => astLs
     }
   }
@@ -2119,7 +2121,8 @@ object RegexRewrite {
 
   private def getMultipleContainsLiterals(ast: RegexAST): Seq[UTF8String] = {
     ast match {
-      case RegexGroup(_, term) => getMultipleContainsLiterals(term)
+      case RegexGroup(RegexGroup.Capturing | RegexGroup.NonCapturing, term) =>
+        getMultipleContainsLiterals(term)
       case RegexChoice(RegexSequence(parts), ls) if isLiteralString(parts) => {
         getMultipleContainsLiterals(ls) match {
           case Seq() => Seq.empty
@@ -2136,7 +2139,8 @@ object RegexRewrite {
     ast match {
       case RegexRepetition(RegexChar('.'), SimpleQuantifier('*')) => true
       case RegexSequence(parts) if parts.forall(isWildcard) => true
-      case RegexGroup(_, term) if isWildcard(term) => true
+      case RegexGroup(RegexGroup.Capturing | RegexGroup.NonCapturing, term)
+          if isWildcard(term) => true
       case _ => false
     }
   }

sql-plugin/src/main/scala/org/apache/spark/sql/rapids/stringFunctions.scala

@@ -1244,7 +1244,7 @@ object GpuRegExpUtils {
 
   def getChoicesFromRegex(regex: RegexAST): Option[Seq[String]] = {
     regex match {
-      case RegexGroup(_, t) =>
+      case RegexGroup(RegexGroup.Capturing | RegexGroup.NonCapturing, t) =>
         getChoicesFromRegex(t)
       case RegexChoice(a, b) =>
         getChoicesFromRegex(a) match {

tests/src/test/scala/com/nvidia/spark/rapids/RegularExpressionParserSuite.scala

@@ -139,7 +139,7 @@ class RegularExpressionParserSuite extends AnyFunSuite {
                 RegexCharacterRange(RegexChar('A'), RegexChar('Z')))),
               SimpleQuantifier('+')
             )
-          )))
+          ))
         ),
         RegexEscaped(']')
       ))
@@ -262,7 +262,7 @@ class RegularExpressionParserSuite extends AnyFunSuite {
 
     assert(parse("(?:a?)") === RegexSequence(ListBuffer(
       RegexGroup(RegexGroup.NonCapturing, RegexSequence(ListBuffer(
-        RegexRepetition(RegexChar('a'), SimpleQuantifier('?')))))))
+        RegexRepetition(RegexChar('a'), SimpleQuantifier('?'))))))))
   }
 
   test("group not starting with ? is a capturing group") {

tests/src/test/scala/com/nvidia/spark/rapids/RegularExpressionRewriteSuite.scala

@@ -97,4 +97,24 @@ class RegularExpressionRewriteSuite extends AnyFunSuite {
     )
     verifyRewritePattern(patterns, excepted)
   }
+
+  test("regex rewrite ignores unsupported group types") {
+    import RegexOptimizationType._
+    // Lookaround, independent, and named-capture groups are not supported on the GPU. They
+    // now parse successfully, so the rewrite optimizer must treat them as opaque (only
+    // capturing/non-capturing groups may be unwrapped) and never mistake them for a simple
+    // contains/multiple-contains/prefix pattern.
+    val patterns = Seq(
+      "(?=abc)",
+      "(?!abc)",
+      "(?<=abc)",
+      "(?<!abc)",
+      "(?>abc)",
+      "(?<n>abc)",
+      "(?<n>abc|def)",
+      "(?>.*)abc"
+    )
+    val excepted = Seq.fill(patterns.length)(NoOptimization)
+    verifyRewritePattern(patterns, excepted)
+  }
 }