Change wording inm error message function named arguments to named parameters since it has a broader usage.

Author: afoucret

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/Analyzer.java

@@ -1405,7 +1405,7 @@ private BitSet gatherPreAnalysisMetrics(LogicalPlan plan, BitSet b) {
     private static class ImplicitCasting extends ParameterizedRule<LogicalPlan, LogicalPlan, AnalyzerContext> {
         @Override
         public LogicalPlan apply(LogicalPlan plan, AnalyzerContext context) {
-            // do implicit casting for function arguments
+            // do implicit casting for named parameters
             return plan.transformExpressionsUp(
                 org.elasticsearch.xpack.esql.core.expression.function.Function.class,
                 e -> ImplicitCasting.cast(e, context.functionRegistry().snapshotRegistry())

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

@@ -653,26 +653,26 @@ public MapExpression visitMapExpression(EsqlBaseParser.MapExpressionContext ctx)
             if (key.isBlank()) {
                 throw new ParsingException(
                     source(ctx),
-                    "Invalid named function argument [{}], empty key is not supported",
+                    "Invalid named parameter [{}], empty key is not supported",
                     entry.getText()
                 );
             }
             if (names.contains(key)) {
-                throw new ParsingException(source(ctx), "Duplicated function arguments with the same name [{}] is not supported", key);
+                throw new ParsingException(source(ctx), "Duplicated named parameters with the same name [{}] is not supported", key);
             }
             Expression value = expression(entry.constant());
             String entryText = entry.getText();
             if (value instanceof Literal l) {
                 if (l.dataType() == NULL) {
-                    throw new ParsingException(source(ctx), "Invalid named function argument [{}], NULL is not supported", entryText);
+                    throw new ParsingException(source(ctx), "Invalid named parameter [{}], NULL is not supported", entryText);
                 }
                 namedArgs.add(Literal.keyword(source(stringCtx), key));
                 namedArgs.add(l);
                 names.add(key);
             } else {
                 throw new ParsingException(
                     source(ctx),
-                    "Invalid named function argument [{}], only constant value is supported",
+                    "Invalid named parameter [{}], only constant value is supported",
                     entryText
                 );
             }

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

@@ -2968,7 +2968,7 @@ public void testNamedFunctionArgumentNotConstant() {
         }
     }
 
-    public void testNamedFunctionArgumentEmptyMap() {
+    public void testNamedFunctionNamedParametersEmptyMap() {
         Map<String, String> commands = Map.ofEntries(
             Map.entry("eval x = {}", "30"),
             Map.entry("where {}", "27"),
@@ -2987,7 +2987,7 @@ public void testNamedFunctionArgumentEmptyMap() {
         }
     }
 
-    public void testNamedFunctionArgumentMapWithNULL() {
+    public void testNamedFunctionNamedParametersMapWithNULL() {
         Map<String, String> commands = Map.ofEntries(
             Map.entry("eval x = {}", "29"),
             Map.entry("where {}", "26"),
@@ -3007,13 +3007,13 @@ public void testNamedFunctionArgumentMapWithNULL() {
                     null,
                     "line 1:{}: {}",
                     error,
-                    "Invalid named function argument [\"option\":null], NULL is not supported"
+                    "Invalid named parameter [\"option\":null], NULL is not supported"
                 )
             );
         }
     }
 
-    public void testNamedFunctionArgumentMapWithEmptyKey() {
+    public void testNamedFunctionNamedParametersMapWithEmptyKey() {
         Map<String, String> commands = Map.ofEntries(
             Map.entry("eval x = {}", "29"),
             Map.entry("where {}", "26"),
@@ -3033,7 +3033,7 @@ public void testNamedFunctionArgumentMapWithEmptyKey() {
                     null,
                     "line 1:{}: {}",
                     error,
-                    "Invalid named function argument [\"\":1], empty key is not supported"
+                    "Invalid named parameter [\"\":1], empty key is not supported"
                 )
             );
             expectError(
@@ -3042,13 +3042,13 @@ public void testNamedFunctionArgumentMapWithEmptyKey() {
                     null,
                     "line 1:{}: {}",
                     error,
-                    "Invalid named function argument [\"  \":1], empty key is not supported"
+                    "Invalid named parameter [\"  \":1], empty key is not supported"
                 )
             );
         }
     }
 
-    public void testNamedFunctionArgumentMapWithDuplicatedKey() {
+    public void testNamedFunctionNamedParametersMapWithDuplicatedKey() {
         Map<String, String> commands = Map.ofEntries(
             Map.entry("eval x = {}", "29"),
             Map.entry("where {}", "26"),
@@ -3068,13 +3068,13 @@ public void testNamedFunctionArgumentMapWithDuplicatedKey() {
                     null,
                     "line 1:{}: {}",
                     error,
-                    "Duplicated function arguments with the same name [dup] is not supported"
+                    "Duplicated named parameters with the same name [dup] is not supported"
                 )
             );
         }
     }
 
-    public void testNamedFunctionArgumentInInvalidPositions() {
+    public void testNamedFunctionNamedParametersInInvalidPositions() {
         // negative, named arguments are not supported outside of a functionExpression where booleanExpression or indexPattern is supported
         String map = "{\"option1\":\"string\", \"option2\":1}";
 
@@ -3103,7 +3103,7 @@ public void testNamedFunctionArgumentInInvalidPositions() {
         }
     }
 
-    public void testNamedFunctionArgumentWithUnsupportedNamedParameterTypes() {
+    public void testNamedFunctionNamedParametersWithUnsupportedNamedParameterTypes() {
         Map<String, String> commands = Map.ofEntries(
             Map.entry("eval x = {}", "29"),
             Map.entry("where {}", "26"),
@@ -3124,7 +3124,7 @@ public void testNamedFunctionArgumentWithUnsupportedNamedParameterTypes() {
                     null,
                     "line 1:{}: {}",
                     error,
-                    "Invalid named function argument [\"option1\":?n1], only constant value is supported"
+                    "Invalid named parameter [\"option1\":?n1], only constant value is supported"
                 )
             );
             expectError(
@@ -3134,7 +3134,7 @@ public void testNamedFunctionArgumentWithUnsupportedNamedParameterTypes() {
                     null,
                     "line 1:{}: {}",
                     error,
-                    "Invalid named function argument [\"option1\":?n1], only constant value is supported"
+                    "Invalid named parameter [\"option1\":?n1], only constant value is supported"
                 )
             );
         }
@@ -3967,7 +3967,7 @@ public void testInvalidCompletion() {
         );
         expectError(
             "FROM foo* | COMPLETION prompt WITH { \"inference_id\": \"inferenceId\", \"unknown_option\": 3 }",
-            "line 1:42: Inavalid option [unknown_option] in COMPLETION, expected one of [[inference_id]]"
+            "line 1:31: Inavalid option [unknown_option] in COMPLETION, expected one of [[inference_id]]"
         );
 
         expectError("FROM foo* | COMPLETION WITH inferenceId", "line 1:24: extraneous input 'WITH' expecting {");