Refactor RegexParser to handle unsupported regex groups

Consolidate the per-type unsupported-group handling in CudfRegexTranspiler so an unexpected group type falls back to the CPU rather than crashing the query. Also cover the empty lookaround forms, which Java accepts.

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

Author: igorpeshansky

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

@@ -203,10 +203,10 @@ class RegexParser(pattern: String) {
             consumeExpected('>')
             RegexGroup.Named(name)
           case _ => throw new RegexUnsupportedException(
-            s"Unexpected character after '<' in group", Some(pos-1))
+            "Unexpected character after '<' in group", Some(pos-1))
         }
         case '<' => throw new RegexUnsupportedException(
-          s"Pattern may not end with trailing '<' in group", Some(pos-1))
+          "Pattern may not end with trailing '<' in group", Some(pos-1))
       }
     } else {
       RegexGroup.Capturing
@@ -252,8 +252,7 @@ class RegexParser(pattern: String) {
               }
           }
         case None =>
-          throw new RegexUnsupportedException(
-                s"Unclosed character class", Some(pos))
+          throw new RegexUnsupportedException("Unclosed character class", Some(pos))
       }
     }
 
@@ -325,7 +324,7 @@ class RegexParser(pattern: String) {
       }
     }
     if (!characterClassComplete) {
-      throw new RegexUnsupportedException(s"Unclosed character class", Some(pos))
+      throw new RegexUnsupportedException("Unclosed character class", Some(pos))
     }
     characterClass
   }
@@ -1592,31 +1591,7 @@ class CudfRegexTranspiler(mode: RegexMode) {
         }
         RegexChoice(ll, rr)
 
-      case g @ RegexGroup(RegexGroup.PositiveLookahead |
-                          RegexGroup.NegativeLookahead |
-                          RegexGroup.PositiveLookbehind |
-                          RegexGroup.NegativeLookbehind |
-                          RegexGroup.Independent |
-                          RegexGroup.Named(_), _) =>
-        val msg = g.groupType match {
-          case RegexGroup.PositiveLookahead =>
-            "Positive lookahead groups are not supported"
-          case RegexGroup.NegativeLookahead =>
-            "Negative lookahead groups are not supported"
-          case RegexGroup.PositiveLookbehind =>
-            "Positive lookbehind groups are not supported"
-          case RegexGroup.NegativeLookbehind =>
-            "Negative lookbehind groups are not supported"
-          case RegexGroup.Independent =>
-            "Independent groups are not supported"
-          case RegexGroup.Named(_) =>
-            "Named capture groups are not supported"
-          case _ =>  // unreachable
-            throw new IllegalStateException(s"Unhandled group type: ${g.groupType}")
-        }
-        throw new RegexUnsupportedException(msg, g.position)
-
-      case RegexGroup(groupType, term) =>
+      case g @ RegexGroup(RegexGroup.Capturing | RegexGroup.NonCapturing, term) =>
         term match {
           case RegexSequence(parts) =>
             parts.foreach { part =>
@@ -1642,7 +1617,26 @@ class CudfRegexTranspiler(mode: RegexMode) {
             }
           case _ =>
         }
-        RegexGroup(groupType, rewrite(term, replacement, None, flags))
+        RegexGroup(g.groupType, rewrite(term, replacement, None, flags))
+
+      case g @ RegexGroup(_, _) =>
+        val msg = g.groupType match {
+          case RegexGroup.PositiveLookahead =>
+            "Positive lookahead groups are not supported"
+          case RegexGroup.NegativeLookahead =>
+            "Negative lookahead groups are not supported"
+          case RegexGroup.PositiveLookbehind =>
+            "Positive lookbehind groups are not supported"
+          case RegexGroup.NegativeLookbehind =>
+            "Negative lookbehind groups are not supported"
+          case RegexGroup.Independent =>
+            "Independent groups are not supported"
+          case RegexGroup.Named(_) =>
+            "Named capture groups are not supported"
+          case _ =>
+            s"Unknown group type: ${g.groupType}"
+        }
+        throw new RegexUnsupportedException(msg, g.position)
 
       case other =>
         throw new RegexUnsupportedException(s"Unhandled expression in transpiler: $other",

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

@@ -159,25 +159,25 @@ class RegularExpressionTranspilerSuite extends AnyFunSuite {
   }
 
   test("cuDF does not support positive or negative lookaround") {
-    val posLookaheadPatterns = Seq("a(?=b)", "a(?=b)c?")
+    val posLookaheadPatterns = Seq("a(?=b)", "a(?=b)c?", "(?=)")
     posLookaheadPatterns.foreach(pattern =>
       assertUnsupported(pattern, RegexFindMode,
         "Positive lookahead groups are not supported")
     )
 
-    val negLookaheadPatterns = Seq("a(?!b)", "a(?!b)c?")
+    val negLookaheadPatterns = Seq("a(?!b)", "a(?!b)c?", "(?!)")
     negLookaheadPatterns.foreach(pattern =>
       assertUnsupported(pattern, RegexFindMode,
         "Negative lookahead groups are not supported")
     )
 
-    val posLookbehindPatterns = Seq("a(?<=b)", "a(?<=b)c?")
+    val posLookbehindPatterns = Seq("a(?<=b)", "a(?<=b)c?", "(?<=)")
     posLookbehindPatterns.foreach(pattern =>
       assertUnsupported(pattern, RegexFindMode,
         "Positive lookbehind groups are not supported")
     )
 
-    val negLookbehindPatterns = Seq("a(?<!b)", "a(?<!b)c?")
+    val negLookbehindPatterns = Seq("a(?<!b)", "a(?<!b)c?", "(?<!)")
     negLookbehindPatterns.foreach(pattern =>
       assertUnsupported(pattern, RegexFindMode,
         "Negative lookbehind groups are not supported")