fix: exponential backtracking on deeply nested bracketed expressions

Remove allowComplexParsing gates from ExpressionList and
ParenthesedExpressionList so ComplexExpressionList (full Expression())
is always used. This lets Condition() handle all parenthesized content
including comparison and boolean operators, eliminating the expensive
speculative LOOKAHEAD(Condition()) and XorExpression fallback in
AndExpression.

Replace syntactic LOOKAHEAD(NamedExpressionListExprFirst()) in
SpecialStringFunctionWithNamedParameters with a lightweight
isNamedExprListAhead() token scan.

Fixes parsing of deeply nested `IF()` and `POSITION(... IN (CASE ...))`.

- fixes #2422

Signed-off-by: Andreas Reichel <andreas@manticore-projects.com>
Signed-off-by: manticore-projects <andreas@manticore-projects.com>

Author: manticore-projects

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt

@@ -597,6 +597,39 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         }
     }
 
+    /**
+     * Lightweight lookahead for SpecialStringFunctionWithNamedParameters:
+     * scans forward from the current position (just past the opening '(')
+     * looking for FROM, IN, or PLACING at bracket nesting depth 0.
+     *
+     * This replaces an expensive syntactic LOOKAHEAD(NamedExpressionListExprFirst())
+     * that caused exponential backtracking with deeply nested expressions.
+     */
+    protected boolean isNamedExprListAhead() {
+        int depth = 0;
+        for (int i = 1; ; i++) {
+            Token t = getToken(i);
+            if (t.kind == EOF) {
+                return false;
+            }
+            if (t.kind == OPENING_BRACKET) {
+                depth++;
+            } else if (t.kind == CLOSING_BRACKET) {
+                if (depth == 0) {
+                    return false;
+                }
+                depth--;
+            } else if (depth == 0) {
+                if (t.kind == K_FROM || t.kind == K_IN || t.kind == K_PLACING) {
+                    return true;
+                }
+                if (t.image.equals(",")) {
+                    return false;
+                }
+            }
+        }
+    }
+
     /**
      * Checks if the next token can start a condition suffix
      * (comparison, IN, BETWEEN, LIKE, IS NULL, etc.)
@@ -6675,45 +6708,21 @@ Expression OrExpression():
 Expression AndExpression() :
 {
     Expression left, right, result;
-    boolean not = false;
-    boolean exclamationMarkNot=false;
 }
 {
-    (
-        // Fast path: when NOT starting with ( or NOT/!, Condition() always succeeds
-        // (PrimaryExpression can always match an identifier, literal, CASE, etc.)
-        // No speculative parsing needed — go directly.
-        LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET
-                    && getToken(1).kind != K_NOT
-                    && !getToken(1).image.equals("!") })
-        left=Condition()
-        |
-        // Slow path: ( or NOT might introduce a parenthesized boolean expression
-        // that Condition() can't handle (because ParenthesedExpressionList uses
-        // SimpleExpression which doesn't support LIKE/IN/BETWEEN/IS).
-        // Try Condition() first (handles "( a + b ) > 5"), fall back to
-        // "(" XorExpression() ")" (handles "( value LIKE '%x%' )").
-        LOOKAHEAD(Condition(), {!interrupted}) left=Condition()
-        |
-        [ <K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; } ]
-        "(" left=XorExpression() ")" {left = new ParenthesedExpressionList(left); if (not) { left = new NotExpression(left, exclamationMarkNot); not = false; } }
-    )
+    // ParenthesedExpressionList always delegates to ComplexExpressionList which
+    // uses full Expression(), so Condition() can handle ALL parenthesized content
+    // (including boolean operators like LIKE/IN/BETWEEN/IS inside parens).
+    // No speculative parsing or XorExpression fallback needed.
+    left=Condition()
     { result = left; }
 
     ( LOOKAHEAD(2)
         { boolean useOperator = false; }
          (<K_AND> | <OP_DOUBLEAND> {useOperator=true;} )
-        (
-            LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET
-                        && getToken(1).kind != K_NOT
-                        && !getToken(1).image.equals("!") })
-            right=Condition()
-            |
-            LOOKAHEAD(Condition(), {!interrupted}) right=Condition()
-            |
-            [ <K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; } ]
-            "(" right=XorExpression() ")" {right = new ParenthesedExpressionList(right); if (not) { right = new NotExpression(right, exclamationMarkNot); not = false; } }
-        )
+
+        right=Condition()
+
         {
             result = new AndExpression(left, right);
             ((AndExpression)result).setUseOperator(useOperator);
@@ -7164,7 +7173,7 @@ ExpressionList ExpressionList() #ExpressionList:
 }
 {
     (
-        LOOKAHEAD(3, { getAsBoolean(Feature.allowComplexParsing) && !interrupted}) expressionList = ComplexExpressionList()
+        LOOKAHEAD(3, { !interrupted }) expressionList = ComplexExpressionList()
         |
         LOOKAHEAD(3) expressionList = SimpleExpressionList()
         |
@@ -7202,7 +7211,7 @@ ParenthesedExpressionList ParenthesedExpressionList():
 {
     "("
     (
-        LOOKAHEAD({ getAsBoolean(Feature.allowComplexParsing) && !interrupted}) expressions = ComplexExpressionList()
+        LOOKAHEAD({ !interrupted }) expressions = ComplexExpressionList()
         |
         expressions = SimpleExpressionList()
     )?
@@ -9300,7 +9309,7 @@ Function SpecialStringFunctionWithNamedParameters() :
 
         "("
         (
-            LOOKAHEAD( NamedExpressionListExprFirst() , { getAsBoolean(Feature.allowComplexParsing) }) namedExpressionList = NamedExpressionListExprFirst()
+            LOOKAHEAD( { isNamedExprListAhead() } ) namedExpressionList = NamedExpressionListExprFirst()
             |
             expressionList=ExpressionList()
         )