(groovy) branch master updated: GROOVY-11688: Potential minor improvement to STC error message

[paulk]

This is an automated email from the ASF dual-hosted git repository.

paulk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git


The following commit(s) were added to refs/heads/master by this push:
     new 4b7fab4c53 GROOVY-11688: Potential minor improvement to STC error 
message
4b7fab4c53 is described below

commit 4b7fab4c534b734af3e41a27ae90dc3bf662200a
Author: Paul King <pa...@asert.com.au>
AuthorDate: Sun Jun 1 13:56:05 2025 +1000

    GROOVY-11688: Potential minor improvement to STC error message
---
 .../transform/stc/StaticTypeCheckingVisitor.java   | 24 ++++++++++++----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git 
a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
 
b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index 2605a17e2e..6e28420b5b 100644
--- 
a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ 
b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -3137,13 +3137,13 @@ out:    if ((samParameterTypes.length == 1 && 
isOrImplements(samParameterTypes[0
     private void checkNamedParamsAnnotation(final Parameter param, final 
MapExpression args) {
         if (!isOrImplements(param.getType(), MAP_TYPE)) return;
         List<MapEntryExpression> entryExpressions = 
args.getMapEntryExpressions();
-        Map<Object, Expression> entries = new LinkedHashMap<>();
+        Map<Object, MapEntryExpression> entries = new LinkedHashMap<>();
         for (MapEntryExpression entry : entryExpressions) {
             Object key = entry.getKeyExpression();
             if (key instanceof ConstantExpression) {
                 key = ((ConstantExpression) key).getValue();
             }
-            entries.put(key, entry.getValueExpression());
+            entries.put(key, entry);
         }
         List<String> collectedNames = new ArrayList<>();
         List<AnnotationNode> annotations = 
param.getAnnotations(NAMED_PARAMS_CLASSNODE);
@@ -3177,21 +3177,22 @@ out:    if ((samParameterTypes.length == 1 && 
isOrImplements(samParameterTypes[0
             }
         }
         if (!collectedNames.isEmpty()) {
-            for (Map.Entry<Object, Expression> entry : entries.entrySet()) {
-                if (!collectedNames.contains(entry.getKey())) {
-                    addStaticTypeError("unexpected named arg: " + 
entry.getKey(), args);
+            for (Map.Entry<Object, MapEntryExpression> entry : 
entries.entrySet()) {
+                Object name = entry.getKey();
+                if (!collectedNames.contains(name)) {
+                    addStaticTypeError("unexpected named arg: " + name, 
entry.getValue());
                 }
             }
         }
     }
 
-    private void processNamedParam(final AnnotationConstantExpression value, 
final Map<Object, Expression> entries, final Expression expression, final 
List<String> collectedNames) {
+    private void processNamedParam(final AnnotationConstantExpression value, 
final Map<Object, MapEntryExpression> entries, final MapExpression args, final 
List<String> collectedNames) {
         AnnotationNode namedParam = (AnnotationNode) value.getValue();
         if 
(!namedParam.getClassNode().getName().equals(NamedParam.class.getName())) 
return;
-        processNamedParam(namedParam, entries, expression, collectedNames);
+        processNamedParam(namedParam, entries, args, collectedNames);
     }
 
-    private void processNamedParam(final AnnotationNode namedParam, final 
Map<Object, Expression> entries, final Expression expression, final 
List<String> collectedNames) {
+    private void processNamedParam(final AnnotationNode namedParam, final 
Map<Object, MapEntryExpression> entries, final MapExpression args, final 
List<String> collectedNames) {
         String name = null;
         boolean required = false;
         ClassNode expectedType = null;
@@ -3210,12 +3211,13 @@ out:    if ((samParameterTypes.length == 1 && 
isOrImplements(samParameterTypes[0
         }
         if (!entries.containsKey(name)) {
             if (required) {
-                addStaticTypeError("required named param '" + name + "' not 
found.", expression);
+                addStaticTypeError("required named param '" + name + "' not 
found.", args);
             }
         } else if (expectedType != null) {
-            ClassNode argumentType = 
getDeclaredOrInferredType(entries.get(name));
+            MapEntryExpression entry = entries.get(name);
+            ClassNode argumentType = 
getDeclaredOrInferredType(entry.getValueExpression());
             if (!isAssignableTo(argumentType, expectedType)) {
-                addStaticTypeError("argument for named param '" + name + "' 
has type '" + prettyPrintType(argumentType) + "' but expected '" + 
prettyPrintType(expectedType) + "'.", expression);
+                addStaticTypeError("argument for named param '" + name + "' 
has type '" + prettyPrintType(argumentType) + "' but expected '" + 
prettyPrintType(expectedType) + "'.", entry);
             }
         }
     }