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)