You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by em...@apache.org on 2022/02/01 17:55:45 UTC

[groovy] 02/11: GROOVY-10027: NamedParam: check against declared/inferred argument type

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

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

commit 19d3a603ba04d4aa49095aec20b5b448b7189b96
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Fri Apr 9 14:31:37 2021 -0500

    GROOVY-10027: NamedParam: check against declared/inferred argument type
    
    Conflicts:
    	src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
---
 .../transform/stc/StaticTypeCheckingVisitor.java   | 23 ++++---
 src/test/groovy/NamedParameterTest.groovy          | 80 ++++++++++++++++++----
 2 files changed, 80 insertions(+), 23 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 3cea7e5..b262e7f 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -2797,19 +2797,26 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
         }
         if (!entries.keySet().contains(name)) {
             if (required) {
-                addStaticTypeError("required named arg '" + name + "' not found.", expression);
+                addStaticTypeError("required named param '" + name + "' not found.", expression);
             }
-        } else {
-            Expression supplied = entries.get(name);
-            if (isCompatibleType(expectedType, expectedType != null, supplied.getType())) {
-                addStaticTypeError("parameter for named arg '" + name + "' has type '" + prettyPrintType(supplied.getType()) +
-                        "' but expected '" + prettyPrintType(expectedType) + "'.", expression);
+        } else if (expectedType != null) {
+            ClassNode argumentType = getDeclaredOrInferredType(entries.get(name));
+            if (!isAssignableTo(argumentType, expectedType)) {
+                addStaticTypeError("argument for named param '" + name + "' has type '" + prettyPrintType(argumentType) + "' but expected '" + prettyPrintType(expectedType) + "'.", expression);
             }
         }
     }
 
-    private boolean isCompatibleType(ClassNode expectedType, boolean b, ClassNode type) {
-        return b && !isAssignableTo(type, expectedType);
+    private ClassNode getDeclaredOrInferredType(Expression expression) {
+        ClassNode declaredOrInferred;
+        // in case of "T t = new ExtendsOrImplementsT()", return T for the expression type
+        if (expression instanceof Variable && !((Variable) expression).isDynamicTyped()) {
+            declaredOrInferred = getOriginalDeclarationType(expression);
+        } else {
+            declaredOrInferred = getType(expression);
+        }
+        // apply instanceof constraints to either option
+        return getInferredTypeFromTempInfo(expression, declaredOrInferred);
     }
 
     /**
diff --git a/src/test/groovy/NamedParameterTest.groovy b/src/test/groovy/NamedParameterTest.groovy
index b0cc07b..5a5b96d 100644
--- a/src/test/groovy/NamedParameterTest.groovy
+++ b/src/test/groovy/NamedParameterTest.groovy
@@ -24,12 +24,12 @@ import groovy.transform.TypeChecked
 
 import static groovy.NamedParameterHelper.myJavaMethod
 
-class NamedParameterTest extends GroovyTestCase {
+final class NamedParameterTest extends GroovyTestCase {
 
     void testPassingNamedParametersToMethod() {
         someMethod(name:"gromit", eating:"nice cheese", times:2)
     }
-    
+
     protected void someMethod(args) {
         assert args.name == "gromit"
         assert args.eating == "nice cheese"
@@ -69,12 +69,15 @@ class NamedParameterTest extends GroovyTestCase {
             import groovy.transform.TypeChecked
             import static groovy.NamedParameterTest.myMethod
 
+            int getAnswer() { 42 }
+
             @TypeChecked
-            def method() {            
-                assert myMethod(foo: 'FOO', bar: 'BAR') == 'foo = FOO, bar = BAR'
-                assert myMethod(bar: 'BAR') == 'foo = null, bar = BAR'
-                assert myMethod(foo: 'FOO', bar: 45, 442) == 'foo = FOO, bar = 45, num = 442'
-                assert myMethod(foo: 'FOO', 542) == 'foo = FOO, bar = null, num = 542'
+            def method() {
+                assert myMethod(foo: 'FOO', bar: 'BAR')          == 'foo = FOO, bar = BAR'
+                assert myMethod(bar: 'BAR')                      == 'foo = null, bar = BAR'
+                assert myMethod(foo: 'FOO', bar: 45, 442)        == 'foo = FOO, bar = 45, num = 442'
+                assert myMethod(foo: 'FOO', 542)                 == 'foo = FOO, bar = null, num = 542'
+                assert myMethod(foo: 'string', bar: answer, 666) == 'foo = string, bar = 42, num = 666' // GROOVY-10027
             }
             method()
         '''
@@ -86,12 +89,12 @@ class NamedParameterTest extends GroovyTestCase {
             import static groovy.NamedParameterTest.myMethod
 
             @TypeChecked
-            def method() {            
+            def method() {
                 myMethod(foo: 'FOO')
             }
             method()
         '''
-        assert message.contains("required named arg 'bar' not found")
+        assert message.contains("required named param 'bar' not found")
     }
 
     void testUnknownName() {
@@ -100,7 +103,7 @@ class NamedParameterTest extends GroovyTestCase {
             import static groovy.NamedParameterTest.myMethod
 
             @TypeChecked
-            def method() {            
+            def method() {
                 myMethod(bar: 'BAR', baz: 'BAZ')
             }
             method()
@@ -108,20 +111,67 @@ class NamedParameterTest extends GroovyTestCase {
         assert message.contains("unexpected named arg: baz")
     }
 
-    void testInvalidType() {
+    // GROOVY-10027
+    void testFlowType() {
+        assertScript '''
+            import groovy.transform.TypeChecked
+            import static groovy.NamedParameterTest.myMethod
+
+            @TypeChecked
+            def method(arg) {
+                if (arg instanceof Integer) {
+                    myMethod(foo: 'x', bar: arg, 123)
+                }
+            }
+            assert method(42) == 'foo = x, bar = 42, num = 123'
+        '''
+    }
+
+    void testInvalidType1() {
         def message = shouldFail '''
             import groovy.transform.TypeChecked
             import static groovy.NamedParameterTest.myMethod
 
             @TypeChecked
-            def method() {            
-                myMethod(foo: 42, 42)
+            def method() {
+                myMethod(foo:42, -1)
+            }
+        '''
+        assert message.contains("argument for named param 'foo' has type 'int' but expected 'java.lang.String'")
+    }
+
+    void testInvalidType2() {
+        def message = shouldFail '''
+            import groovy.transform.TypeChecked
+            import static groovy.NamedParameterTest.myMethod
+
+            @TypeChecked
+            def method() {
+                int answer = 42
+                myMethod(foo:answer, -1)
+            }
+        '''
+        assert message.contains("argument for named param 'foo' has type 'int' but expected 'java.lang.String'")
+    }
+
+    // GROOVY-10027
+    void testInvalidType3() {
+        def message = shouldFail '''
+            import groovy.transform.TypeChecked
+            import static groovy.NamedParameterTest.myMethod
+
+            int getAnswer() { 42 }
+
+            @TypeChecked
+            def method() {
+                myMethod(foo:answer, -1)
             }
-            method()
         '''
-        assert message.contains("parameter for named arg 'foo' has type 'int' but expected 'java.lang.String'")
+        assert message.contains("argument for named param 'foo' has type 'int' but expected 'java.lang.String'")
     }
 
+    //--------------------------------------------------------------------------
+
     static String myMethod(@NamedParams([
             @NamedParam(value = "foo"),
             @NamedParam(value = "bar", type = String, required = true)