ESQL: Catch parsing exception

When an invalid popMode occurs (due to an invalid query), ANTLR throws
 an out-of-channel exception, bypassing the existing checks.
This PR extends the checks and properly reports the error back to the
 user

Fix #119025

Author: costin

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/parser/EsqlParser.java

@@ -23,6 +23,7 @@
 import org.elasticsearch.xpack.esql.telemetry.PlanTelemetry;
 
 import java.util.BitSet;
+import java.util.EmptyStackException;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.regex.Matcher;
@@ -111,6 +112,9 @@ private <T> T invokeParser(
             return result.apply(new AstBuilder(new ExpressionBuilder.ParsingContext(params, metrics)), tree);
         } catch (StackOverflowError e) {
             throw new ParsingException("ESQL statement is too large, causing stack overflow when generating the parsing tree: [{}]", query);
+        // likely thrown by an invalid popMode (such as extra closing parenthesis)
+        } catch (EmptyStackException ese) {
+            throw new ParsingException("Invalid query [{}]", query);
         }
     }
 

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/parser/StatementParserTests.java

@@ -324,7 +324,7 @@ public void testStatsWithoutAggsOrGroup() {
     }
 
     public void testAggsWithGroupKeyAsAgg() {
-        var queries = new String[] { """
+        var queries = new String[]{"""
             row a = 1, b = 2
             | stats a by a
             """, """
@@ -337,7 +337,7 @@ public void testAggsWithGroupKeyAsAgg() {
             """, """
             row a = 1, b = 2
             | stats x = a by a
-            """ };
+            """};
 
         for (String query : queries) {
             expectVerificationError(query, "grouping key [a] already specified in the STATS BY clause");
@@ -683,16 +683,16 @@ public void testInvalidQuotingAsLookupIndexPattern() {
     }
 
     public void testIdentifierAsFieldName() {
-        String[] operators = new String[] { "==", "!=", ">", "<", ">=", "<=" };
-        Class<?>[] expectedOperators = new Class<?>[] {
+        String[] operators = new String[]{"==", "!=", ">", "<", ">=", "<="};
+        Class<?>[] expectedOperators = new Class<?>[]{
             Equals.class,
             Not.class,
             GreaterThan.class,
             LessThan.class,
             GreaterThanOrEqual.class,
-            LessThanOrEqual.class };
-        String[] identifiers = new String[] { "abc", "`abc`", "ab_c", "a.b.c", "@a", "a.@b", "`[email protected]`" };
-        String[] expectedIdentifiers = new String[] { "abc", "abc", "ab_c", "a.b.c", "@a", "a.@b", "[email protected]" };
+            LessThanOrEqual.class};
+        String[] identifiers = new String[]{"abc", "`abc`", "ab_c", "a.b.c", "@a", "a.@b", "`[email protected]`"};
+        String[] expectedIdentifiers = new String[]{"abc", "abc", "ab_c", "a.b.c", "@a", "a.@b", "[email protected]"};
         LogicalPlan where;
         for (int i = 0; i < operators.length; i++) {
             for (int j = 0; j < identifiers.length; j++) {
@@ -848,7 +848,7 @@ public void testSingleLineComments() {
     }
 
     public void testNewLines() {
-        String[] delims = new String[] { "", "\r", "\n", "\r\n" };
+        String[] delims = new String[]{"", "\r", "\n", "\r\n"};
         Function<String, String> queryFun = d -> d + "from " + d + " foo " + d + "| eval " + d + " x = concat(bar, \"baz\")" + d;
         LogicalPlan reference = statement(queryFun.apply(delims[0]));
         for (int i = 1; i < delims.length; i++) {
@@ -2722,13 +2722,13 @@ public void testNamedFunctionArgumentNotInMap() {
 
     public void testNamedFunctionArgumentNotConstant() {
         Map<String, String[]> commands = Map.ofEntries(
-            Map.entry("eval x = {}", new String[] { "31", "35" }),
-            Map.entry("where {}", new String[] { "28", "32" }),
-            Map.entry("stats {}", new String[] { "28", "32" }),
-            Map.entry("stats agg() by {}", new String[] { "37", "41" }),
-            Map.entry("sort {}", new String[] { "27", "31" }),
-            Map.entry("dissect {} \"%{bar}\"", new String[] { "30", "34" }),
-            Map.entry("grok {} \"%{WORD:foo}\"", new String[] { "27", "31" })
+            Map.entry("eval x = {}", new String[]{"31", "35"}),
+            Map.entry("where {}", new String[]{"28", "32"}),
+            Map.entry("stats {}", new String[]{"28", "32"}),
+            Map.entry("stats agg() by {}", new String[]{"37", "41"}),
+            Map.entry("sort {}", new String[]{"27", "31"}),
+            Map.entry("dissect {} \"%{bar}\"", new String[]{"30", "34"}),
+            Map.entry("grok {} \"%{WORD:foo}\"", new String[]{"27", "31"})
         );
 
         for (Map.Entry<String, String[]> command : commands.entrySet()) {
@@ -3091,7 +3091,7 @@ public void testInvalidFork() {
     }
 
     public void testFieldNamesAsCommands() throws Exception {
-        String[] keywords = new String[] {
+        String[] keywords = new String[]{
             "dissect",
             "drop",
             "enrich",
@@ -3104,7 +3104,7 @@ public void testFieldNamesAsCommands() throws Exception {
             "mv_expand",
             "rename",
             "sort",
-            "stats" };
+            "stats"};
         for (String keyword : keywords) {
             var plan = statement("FROM test | STATS avg(" + keyword + ")");
             var aggregate = as(plan, Aggregate.class);
@@ -3152,4 +3152,11 @@ public void testValidRrf() {
 
         assertThat(rrfScoreEval.child(), instanceOf(Fork.class));
     }
+
+    public void testUnclosedParenthesis() {
+        String [] queries = { "row a = )" ,  "row ]", "from source | eval x = [1,2,3]]"};
+        for (String q : queries) {
+            expectError(q, "Invalid query");
+        }
+    }
 }