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/07/23 01:53:51 UTC
[groovy] branch GROOVY_4_0_X updated (28c582afad -> 9c7bb5d34c)
This is an automated email from the ASF dual-hosted git repository.
emilles pushed a change to branch GROOVY_4_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
from 28c582afad GROOVY-10699: STC: resolve type arguments from closure/lambda parameters
new 16aaa09d03 GROOVY-10701: STC: closure/lambda ternary operator target type
new 9c7bb5d34c GROOVY-10699: STC: `<>` ctor call closure/lambda parameter type checking
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../java/org/codehaus/groovy/ast/ClassHelper.java | 1 +
.../transform/stc/StaticTypeCheckingVisitor.java | 321 ++++++++++-----------
.../groovy/transform/stc/GenericsSTCTest.groovy | 50 +++-
.../transform/stc/TernaryOperatorSTCTest.groovy | 49 ++++
4 files changed, 257 insertions(+), 164 deletions(-)
[groovy] 02/02: GROOVY-10699: STC: `<>` ctor call closure/lambda parameter type checking
Posted by em...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
emilles pushed a commit to branch GROOVY_4_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 9c7bb5d34c43efd345b5664498ef81c6a6f4df66
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Fri Jul 22 15:40:47 2022 -0500
GROOVY-10699: STC: `<>` ctor call closure/lambda parameter type checking
---
.../transform/stc/StaticTypeCheckingVisitor.java | 52 ++++++++++++----------
.../groovy/transform/stc/GenericsSTCTest.groovy | 50 ++++++++++++++++++++-
2 files changed, 78 insertions(+), 24 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 cd15553533..99fba116aa 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -2300,8 +2300,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
&& parameters.length == argumentTypes.length - 1) {
ctor = typeCheckMapConstructor(call, receiver, arguments);
} else {
- if (asBoolean(receiver.getGenericsTypes())) { // GROOVY-10283, GROOVY-10316, GROOVY-10482, GROOVY-10624, et al.
- Map<GenericsTypeName, GenericsType> context = extractPlaceHoldersVisibleToDeclaration(receiver, ctor, argumentList);
+ if (asBoolean(receiver.getGenericsTypes())) { // GROOVY-10283, GROOVY-10316, GROOVY-10482, GROOVY-10624
+ Map<GenericsTypeName, GenericsType> context = extractPlaceHolders(receiver, ctor.getDeclaringClass());
parameters = Arrays.stream(parameters).map(p -> new Parameter(applyGenericsContext(context, p.getType()), p.getName())).toArray(Parameter[]::new);
}
resolvePlaceholdersFromImplicitTypeHints(argumentTypes, argumentList, parameters);
@@ -2658,8 +2658,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
protected void addTypeCheckingInfoAnnotation(final MethodNode node) {
- // TypeChecked$TypeCheckingInfo can not be applied on constructors
- if (node instanceof ConstructorNode) return;
+ // TypeChecked$TypeCheckingInfo cannot be applied on constructors
+ if (node.isConstructor()) return;
// if a returned inferred type is available and no @TypeCheckingInfo is on node, then add an
// annotation to the method node
@@ -2943,23 +2943,30 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
doInferClosureParameterTypes(receiver, arguments, expression, method, value, conflictResolver, options);
}
} else if (isSAMType(target.getOriginType())) { // SAM-type coercion
- Map<GenericsTypeName, GenericsType> context = extractPlaceHoldersVisibleToDeclaration(receiver, method, arguments);
- GenericsType[] typeParameters = method instanceof ConstructorNode ? method.getDeclaringClass().getGenericsTypes() : applyGenericsContext(context, method.getGenericsTypes());
+ boolean isConstructor = method.isConstructor();
+ boolean hasTypeArguments = asBoolean(receiver.getGenericsTypes());
+ Map<GenericsTypeName, GenericsType> context = isConstructor && !hasTypeArguments ? new HashMap<>() // GROOVY-10699
+ : extractPlaceHoldersVisibleToDeclaration(receiver, method, arguments);
+ GenericsType[] typeParameters = isConstructor ? method.getDeclaringClass().getGenericsTypes() : applyGenericsContext(context, method.getGenericsTypes());
if (typeParameters != null) {
boolean typeParametersResolved = false;
// first check for explicit type arguments
- Expression emc = typeCheckingContext.getEnclosingMethodCall();
- if (emc instanceof MethodCallExpression) {
- MethodCallExpression mce = (MethodCallExpression) emc;
- if (mce.getArguments() == arguments) {
- GenericsType[] typeArguments = mce.getGenericsTypes();
- if (typeArguments != null) {
- int n = typeParameters.length;
- if (n == typeArguments.length) {
- typeParametersResolved = true;
- for (int i = 0; i < n; i += 1) {
- context.put(new GenericsTypeName(typeParameters[i].getName()), typeArguments[i]);
+ if (isConstructor) {
+ typeParametersResolved = hasTypeArguments;
+ } else {
+ Expression emc = typeCheckingContext.getEnclosingMethodCall();
+ if (emc instanceof MethodCallExpression) {
+ MethodCallExpression mce = (MethodCallExpression) emc;
+ if (mce.getArguments() == arguments) {
+ GenericsType[] typeArguments = mce.getGenericsTypes();
+ if (typeArguments != null) {
+ int n = typeParameters.length;
+ if (n == typeArguments.length) {
+ typeParametersResolved = true;
+ for (int i = 0; i < n; i += 1) {
+ context.put(new GenericsTypeName(typeParameters[i].getName()), typeArguments[i]);
+ }
}
}
}
@@ -4820,7 +4827,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
}
MethodNode stubbed;
- if ("<init>".equals(method.getName())) {
+ if (method.isConstructor()) {
stubbed = new ConstructorNode(
method.getModifiers(),
newParams,
@@ -4926,8 +4933,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
}
- if (!"<init>".equals(name) && !"<clinit>".equals(name)) {
- // lookup in DGM methods too
+ if (!name.endsWith("init>")) { // also search for extension methods
findDGMMethodsByNameAndArguments(getSourceUnit().getClassLoader(), receiver, name, args, methods);
}
methods = filterMethodsByVisibility(methods, typeCheckingContext.getEnclosingClassNode());
@@ -5295,7 +5301,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
* @param explicitTypeHints type arguments (optional), for example {@code Collections.<String>emptyList()}
*/
protected ClassNode inferReturnTypeGenerics(final ClassNode receiver, final MethodNode method, final Expression arguments, final GenericsType[] explicitTypeHints) {
- ClassNode returnType = method instanceof ConstructorNode ? method.getDeclaringClass() : method.getReturnType();
+ ClassNode returnType = method.isConstructor() ? method.getDeclaringClass() : method.getReturnType();
if (!GenericsUtils.hasUnresolvedGenerics(returnType)) {
// GROOVY-7538: replace "Type<?>" with "Type<? extends/super X>" for any "Type<T extends/super X>"
if (getGenericsWithoutArray(returnType) != null) returnType = boundUnboundedWildcards(returnType);
@@ -5309,9 +5315,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
return inferReturnTypeGenerics(receiver, extension, args, explicitTypeHints);
}
- Map<GenericsTypeName, GenericsType> context = method.isStatic() || method instanceof ConstructorNode
+ Map<GenericsTypeName, GenericsType> context = method.isStatic() || method.isConstructor()
? null : extractPlaceHoldersVisibleToDeclaration(receiver, method, arguments);
- GenericsType[] methodGenericTypes = method instanceof ConstructorNode ? method.getDeclaringClass().getGenericsTypes() : applyGenericsContext(context, method.getGenericsTypes());
+ GenericsType[] methodGenericTypes = method.isConstructor() ? method.getDeclaringClass().getGenericsTypes() : applyGenericsContext(context, method.getGenericsTypes());
// 1) resolve type parameters of method
diff --git a/src/test/groovy/transform/stc/GenericsSTCTest.groovy b/src/test/groovy/transform/stc/GenericsSTCTest.groovy
index eaa5a038e1..ee17a5d5f3 100644
--- a/src/test/groovy/transform/stc/GenericsSTCTest.groovy
+++ b/src/test/groovy/transform/stc/GenericsSTCTest.groovy
@@ -1154,7 +1154,7 @@ class GenericsSTCTest extends StaticTypeCheckingTestCase {
class B<T1 extends Number, T2 extends A<C, ? extends T1>> {
T2 t
B(T2 t) {
- this.t = t
+ this.t = t // Cannot assign value of type A<C,? extends T1> to variable of type T2
}
}
class C {
@@ -1422,6 +1422,54 @@ class GenericsSTCTest extends StaticTypeCheckingTestCase {
'''
}
+ // GROOVY-10699
+ void testDiamondInferrenceFromConstructor33() {
+ assertScript '''
+ class A<T> {
+ A(B<T> b_of_t) {
+ }
+ }
+ class B<T> {
+ B(T t) {
+ }
+ }
+
+ @ASTTest(phase=INSTRUCTION_SELECTION, value={
+ def type = node.getNodeMetaData(INFERRED_TYPE)
+ assert type.toString(false) == 'A<java.lang.String>'
+ })
+ def x = new A<>(new B<>('str'))
+ '''
+
+ assertScript '''import java.util.function.Consumer
+ class C<T> {
+ C(Consumer<T> consumer_of_t) {
+ consumer_of_t.accept(null)
+ }
+ }
+
+ @ASTTest(phase=INSTRUCTION_SELECTION, value={
+ def type = node.getNodeMetaData(INFERRED_TYPE)
+ assert type.toString(false) == 'C<java.lang.Object>' // TODO: String
+ })
+ def y = new C<>((String s) -> { print(s); }) // error: Expected type Object for lambda parameter: s
+ '''
+
+ assertScript '''import java.util.function.Supplier
+ class D<T> {
+ D(Supplier<T> supplier_of_t) {
+ T t = supplier_of_t.get()
+ }
+ }
+
+ @ASTTest(phase=INSTRUCTION_SELECTION, value={
+ def type = node.getNodeMetaData(INFERRED_TYPE)
+ assert type.toString(false) == 'D<java.lang.String>'
+ })
+ def z = new D<>(() -> 'str')
+ '''
+ }
+
// GROOVY-10280
void testTypeArgumentPropagation() {
assertScript '''
[groovy] 01/02: GROOVY-10701: STC: closure/lambda ternary operator target type
Posted by em...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
emilles pushed a commit to branch GROOVY_4_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 16aaa09d033d7961cee2e6d2b21c6b86d9df4259
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Fri Jul 22 20:32:38 2022 -0500
GROOVY-10701: STC: closure/lambda ternary operator target type
4_0_X backport
---
.../java/org/codehaus/groovy/ast/ClassHelper.java | 1 +
.../transform/stc/StaticTypeCheckingVisitor.java | 269 ++++++++++-----------
.../transform/stc/TernaryOperatorSTCTest.groovy | 49 ++++
3 files changed, 179 insertions(+), 140 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
index e190ffcfb3..d4daf9face 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
@@ -560,6 +560,7 @@ public class ClassHelper {
* @return the method node if type is a SAM type, null otherwise
*/
public static MethodNode findSAM(final ClassNode type) {
+ if (type == null) return null;
if (type.isInterface()) {
MethodNode sam = null;
for (MethodNode mn : type.getAbstractMethods()) {
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 d8f43a852b..cd15553533 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -594,30 +594,30 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (enclosingClosure != null) {
switch (name) {
- case "delegate":
- DelegationMetadata dm = getDelegationMetadata(enclosingClosure.getClosureExpression());
- if (dm != null) {
- storeType(vexp, dm.getType());
- return;
- }
- // falls through
- case "owner":
- if (typeCheckingContext.getEnclosingClosureStack().size() > 1) {
- storeType(vexp, CLOSURE_TYPE);
- return;
- }
- // falls through
- case "thisObject":
- storeType(vexp, typeCheckingContext.getEnclosingClassNode());
- return;
- case "parameterTypes":
- storeType(vexp, CLASS_Type.makeArray());
+ case "delegate":
+ DelegationMetadata dm = getDelegationMetadata(enclosingClosure.getClosureExpression());
+ if (dm != null) {
+ storeType(vexp, dm.getType());
return;
- case "maximumNumberOfParameters":
- case "resolveStrategy":
- case "directive":
- storeType(vexp, int_TYPE);
+ }
+ // falls through
+ case "owner":
+ if (typeCheckingContext.getEnclosingClosureStack().size() > 1) {
+ storeType(vexp, CLOSURE_TYPE);
return;
+ }
+ // falls through
+ case "thisObject":
+ storeType(vexp, typeCheckingContext.getEnclosingClassNode());
+ return;
+ case "parameterTypes":
+ storeType(vexp, CLASS_Type.makeArray());
+ return;
+ case "maximumNumberOfParameters":
+ case "resolveStrategy":
+ case "directive":
+ storeType(vexp, int_TYPE);
+ return;
}
}
@@ -1072,7 +1072,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private static boolean isClosureWithType(final ClassNode type) {
- return type.equals(CLOSURE_TYPE) && Optional.ofNullable(type.getGenericsTypes()).filter(gts -> gts != null && gts.length == 1).isPresent();
+ return CLOSURE_TYPE.equals(type) && Optional.ofNullable(type.getGenericsTypes()).filter(gts -> gts != null && gts.length == 1).isPresent();
}
private static boolean isCompoundAssignment(final Expression exp) {
@@ -1084,15 +1084,13 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
protected ClassNode getOriginalDeclarationType(final Expression lhs) {
- if (lhs instanceof VariableExpression) {
- Variable var = findTargetVariable((VariableExpression) lhs);
- if (!(var instanceof DynamicVariable || var instanceof PropertyNode)) {
- return var.getOriginType();
- }
- } else if (lhs instanceof FieldExpression) {
- return ((FieldExpression) lhs).getField().getOriginType();
+ Variable var = null;
+ if (lhs instanceof FieldExpression) {
+ var = ((FieldExpression) lhs).getField();
+ } else if (lhs instanceof VariableExpression) {
+ var = findTargetVariable((VariableExpression) lhs);
}
- return getType(lhs);
+ return var != null && !(var instanceof DynamicVariable) ? var.getOriginType() : getType(lhs);
}
protected void inferDiamondType(final ConstructorCallExpression cce, final ClassNode lType) {
@@ -1498,7 +1496,10 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
ClassNode rawType = objectExpressionType.getPlainNodeReference();
inferDiamondType((ConstructorCallExpression) objectExpression, rawType);
}
- List<ClassNode> enclosingTypes = typeCheckingContext.getEnclosingClassNodes();
+ // enclosing excludes classes that skip STC
+ Set<ClassNode> enclosingTypes = new LinkedHashSet<>();
+ enclosingTypes.add(typeCheckingContext.getEnclosingClassNode());
+ enclosingTypes.addAll(enclosingTypes.iterator().next().getOuterClasses());
boolean staticOnlyAccess = isClassClassNodeWrappingConcreteType(objectExpressionType);
if (staticOnlyAccess && "this".equals(propertyName)) {
@@ -1710,15 +1711,16 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
return foundGetterOrSetter;
}
- private static boolean hasAccessToField(final ClassNode accessor, final FieldNode field) {
- if (field.isPublic() || accessor.equals(field.getDeclaringClass())) {
+ private static boolean hasAccessToMember(final ClassNode accessor, final ClassNode receiver, final int modifiers) {
+ if (Modifier.isPublic(modifiers)
+ || accessor.equals(receiver)
+ || accessor.getOuterClasses().contains(receiver)) {
return true;
}
- if (field.isProtected()) {
- return accessor.isDerivedFrom(field.getDeclaringClass());
- } else {
- return !field.isPrivate() && Objects.equals(accessor.getPackageName(), field.getDeclaringClass().getPackageName());
+ if (!Modifier.isPrivate(modifiers) && Objects.equals(accessor.getPackageName(), receiver.getPackageName())) {
+ return true;
}
+ return Modifier.isProtected(modifiers) && accessor.isDerivedFrom(receiver);
}
private MethodNode findGetter(final ClassNode current, String name, final boolean searchOuterClasses) {
@@ -1776,10 +1778,10 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
} else {
// map*.property syntax acts on Entry
switch (pexp.getPropertyAsString()) {
- case "key":
+ case "key":
pexp.putNodeMetaData(READONLY_PROPERTY,Boolean.TRUE); // GROOVY-10326
return makeClassSafe0(LIST_TYPE, gts[0]);
- case "value":
+ case "value":
GenericsType v = gts[1];
if (!v.isWildcard()
&& !Modifier.isFinal(v.getType().getModifiers())
@@ -1787,7 +1789,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
v = GenericsUtils.buildWildcardType(v.getType()); // GROOVY-10325
}
return makeClassSafe0(LIST_TYPE, v);
- default:
+ default:
addStaticTypeError("Spread operator on map only allows one of [key,value]", pexp);
}
}
@@ -1831,7 +1833,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private boolean storeField(final FieldNode field, final PropertyExpression expressionToStoreOn, final ClassNode receiver, final ClassCodeVisitorSupport visitor, final String delegationData, final boolean lhsOfAssignment) {
if (visitor != null) visitor.visitField(field);
checkOrMarkPrivateAccess(expressionToStoreOn, field, lhsOfAssignment);
- boolean accessible = hasAccessToField(isSuperExpression(expressionToStoreOn.getObjectExpression()) ? typeCheckingContext.getEnclosingClassNode() : receiver, field);
+ boolean accessible = hasAccessToMember(isSuperExpression(expressionToStoreOn.getObjectExpression()) ? typeCheckingContext.getEnclosingClassNode() : receiver, field.getDeclaringClass(), field.getModifiers());
if (expressionToStoreOn instanceof AttributeExpression) { // TODO: expand to include PropertyExpression
if (!accessible) {
@@ -2722,9 +2724,6 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
break;
}
}
- if (mn == null) {
- throw new GroovyBugError("Invalid state finding valid method: receivers should never be empty and findMethod should never return null");
- }
if (mn.isEmpty()) {
mn = extension.handleMissingMethod(receiver, name, argumentList, args, call);
}
@@ -2737,14 +2736,13 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
MethodNode directMethodCallCandidate = mn.get(0);
ClassNode returnType = getType(directMethodCallCandidate);
if (returnType.isUsingGenerics() && !returnType.isEnum()) {
- visitMethodCallArguments(receiver, argumentList, true, directMethodCallCandidate);
- ClassNode irtg = inferReturnTypeGenerics(chosenReceiver.getType(), directMethodCallCandidate, callArguments);
- returnType = irtg != null && implementsInterfaceOrIsSubclassOf(irtg, returnType) ? irtg : returnType;
- callArgsVisited = true;
+ visitMethodCallArguments(receiver, argumentList, true, directMethodCallCandidate); callArgsVisited = true;
+ ClassNode rt = inferReturnTypeGenerics(chosenReceiver.getType(), directMethodCallCandidate, argumentList);
+ if (rt != null && implementsInterfaceOrIsSubclassOf(rt, returnType))
+ returnType = rt;
}
storeType(call, returnType);
storeTargetMethod(call, directMethodCallCandidate);
-
} else {
addAmbiguousErrorMessage(mn, name, args, call);
}
@@ -3150,26 +3148,26 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
ClassNode returnType = new ClassNode("ClForInference$" + UNIQUE_LONG.incrementAndGet(), 0, OBJECT_TYPE).getPlainNodeReference();
returnType.setGenericsTypes(Arrays.stream(signature).map(ClassNode::asGenericsType).toArray(GenericsType[]::new));
- MethodNode dummyMN = selectedMethod instanceof ExtensionMethodNode ? ((ExtensionMethodNode) selectedMethod).getExtensionMethodNode() : selectedMethod;
- dummyMN = new MethodNode(dummyMN.getName(), dummyMN.getModifiers(), returnType, dummyMN.getParameters(), dummyMN.getExceptions(), null);
- dummyMN.setDeclaringClass(selectedMethod.getDeclaringClass());
- dummyMN.setGenericsTypes(selectedMethod.getGenericsTypes());
+ MethodNode methodNode = selectedMethod instanceof ExtensionMethodNode ? ((ExtensionMethodNode) selectedMethod).getExtensionMethodNode() : selectedMethod;
+ methodNode = new MethodNode("$$", methodNode.getModifiers(), returnType, methodNode.getParameters(), methodNode.getExceptions(), null);
+ methodNode.setDeclaringClass(selectedMethod.getDeclaringClass());
+ methodNode.setGenericsTypes(selectedMethod.getGenericsTypes());
if (selectedMethod instanceof ExtensionMethodNode) {
- dummyMN = new ExtensionMethodNode(
- dummyMN,
- dummyMN.getName(),
- dummyMN.getModifiers(),
+ methodNode = new ExtensionMethodNode(
+ methodNode,
+ methodNode.getName(),
+ methodNode.getModifiers(),
returnType,
selectedMethod.getParameters(),
selectedMethod.getExceptions(),
null,
((ExtensionMethodNode) selectedMethod).isStaticExtension()
);
- dummyMN.setDeclaringClass(selectedMethod.getDeclaringClass());
- dummyMN.setGenericsTypes(selectedMethod.getGenericsTypes());
+ methodNode.setDeclaringClass(selectedMethod.getDeclaringClass());
+ methodNode.setGenericsTypes(selectedMethod.getGenericsTypes());
}
- returnType = inferReturnTypeGenerics(receiver, dummyMN, arguments);
+ returnType = inferReturnTypeGenerics(receiver, methodNode, arguments);
GenericsType[] returnTypeGenerics = returnType.getGenericsTypes();
for (int i = 0, n = returnTypeGenerics.length; i < n; i += 1) {
GenericsType gt = returnTypeGenerics[i];
@@ -3293,30 +3291,30 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static void addReceivers(final List<Receiver<String>> receivers, final Collection<Receiver<String>> owners, final DelegationMetadata dmd, final String path) {
int strategy = dmd.getStrategy();
switch (strategy) {
- case Closure.DELEGATE_ONLY:
- case Closure.DELEGATE_FIRST:
- addDelegateReceiver(receivers, dmd.getType(), path + "delegate");
- if (strategy == Closure.DELEGATE_FIRST) {
- if (dmd.getParent() == null) {
- receivers.addAll(owners);
- } else {
- //receivers.add(new Receiver<String>(CLOSURE_TYPE, path + "owner"));
- addReceivers(receivers, owners, dmd.getParent(), path + "owner.");
- }
- }
- break;
- case Closure.OWNER_ONLY:
- case Closure.OWNER_FIRST:
+ case Closure.DELEGATE_ONLY:
+ case Closure.DELEGATE_FIRST:
+ addDelegateReceiver(receivers, dmd.getType(), path + "delegate");
+ if (strategy == Closure.DELEGATE_FIRST) {
if (dmd.getParent() == null) {
receivers.addAll(owners);
} else {
//receivers.add(new Receiver<String>(CLOSURE_TYPE, path + "owner"));
addReceivers(receivers, owners, dmd.getParent(), path + "owner.");
}
- if (strategy == Closure.OWNER_FIRST) {
- addDelegateReceiver(receivers, dmd.getType(), path + "delegate");
- }
- break;
+ }
+ break;
+ case Closure.OWNER_ONLY:
+ case Closure.OWNER_FIRST:
+ if (dmd.getParent() == null) {
+ receivers.addAll(owners);
+ } else {
+ //receivers.add(new Receiver<String>(CLOSURE_TYPE, path + "owner"));
+ addReceivers(receivers, owners, dmd.getParent(), path + "owner.");
+ }
+ if (strategy == Closure.OWNER_FIRST) {
+ addDelegateReceiver(receivers, dmd.getType(), path + "delegate");
+ }
+ break;
}
}
@@ -3375,21 +3373,21 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
boolean isCallOnClosure = false;
FieldNode fieldNode = null;
switch (name) {
- case "call":
- case "doCall":
- if (!isThisObjectExpression) {
- isCallOnClosure = receiver.equals(CLOSURE_TYPE);
- break;
- }
- default:
- if (isThisObjectExpression) {
- ClassNode enclosingType = typeCheckingContext.getEnclosingClassNode();
- fieldNode = enclosingType.getDeclaredField(name);
- if (fieldNode != null && getType(fieldNode).equals(CLOSURE_TYPE)
- && !enclosingType.hasPossibleMethod(name, callArguments)) {
- isCallOnClosure = true;
- }
+ case "call":
+ case "doCall":
+ if (!isThisObjectExpression) {
+ isCallOnClosure = receiver.equals(CLOSURE_TYPE);
+ break;
+ }
+ default:
+ if (isThisObjectExpression) {
+ ClassNode enclosingType = typeCheckingContext.getEnclosingClassNode();
+ fieldNode = enclosingType.getDeclaredField(name);
+ if (fieldNode != null && getType(fieldNode).equals(CLOSURE_TYPE)
+ && !enclosingType.hasPossibleMethod(name, callArguments)) {
+ isCallOnClosure = true;
}
+ }
}
try {
@@ -3752,7 +3750,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
/**
- * Given an object expression (a receiver expression), generate the list of potential receiver types.
+ * Given an object expression (a message receiver expression), generate list
+ * of possible types.
*
* @param objectExpression the receiver expression
* @return the list of types the receiver may be
@@ -3762,7 +3761,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
List<Receiver<String>> owners = new ArrayList<>();
if (typeCheckingContext.delegationMetadata != null
&& objectExpression instanceof VariableExpression
- && ((VariableExpression) objectExpression).getName().equals("owner")
+ && ((Variable) objectExpression).getName().equals("owner")
&& /*isNested:*/typeCheckingContext.delegationMetadata.getParent() != null) {
List<Receiver<String>> enclosingClass = Collections.singletonList(
Receiver.make(typeCheckingContext.getEnclosingClassNode()));
@@ -3778,7 +3777,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
if (typeCheckingContext.lastImplicitItType != null
&& objectExpression instanceof VariableExpression
- && ((VariableExpression) objectExpression).getName().equals("it")) {
+ && ((Variable) objectExpression).getName().equals("it")) {
owners.add(Receiver.make(typeCheckingContext.lastImplicitItType));
}
if (isClassClassNodeWrappingConcreteType(receiver)) {
@@ -4180,9 +4179,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// char c = (char) ...
} else if (sourceIsNull && isPrimitiveType(targetType) && !isPrimitiveBoolean(targetType)) {
return false;
- } else if ((expressionType.getModifiers() & Opcodes.ACC_FINAL) == 0 && targetType.isInterface()) {
+ } else if (!Modifier.isFinal(expressionType.getModifiers()) && targetType.isInterface()) {
return true;
- } else if ((targetType.getModifiers() & Opcodes.ACC_FINAL) == 0 && expressionType.isInterface()) {
+ } else if (!Modifier.isFinal(targetType.getModifiers()) && expressionType.isInterface()) {
return true;
} else if (!isAssignableTo(targetType, expressionType) && !implementsInterfaceOrIsSubclassOf(expressionType, targetType)) {
return false;
@@ -4229,15 +4228,19 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
* @param type the inferred type of {@code expr}
*/
private ClassNode checkForTargetType(final Expression expr, final ClassNode type) {
- ClassNode sourceType = Optional.ofNullable(getInferredReturnType(expr)).orElse(type);
-
+ ClassNode sourceType = type;
ClassNode targetType = null;
MethodNode enclosingMethod = typeCheckingContext.getEnclosingMethod();
+ MethodCall enclosingMethodCall = (MethodCall)typeCheckingContext.getEnclosingMethodCall();
BinaryExpression enclosingExpression = typeCheckingContext.getEnclosingBinaryExpression();
if (enclosingExpression != null
&& isAssignment(enclosingExpression.getOperation().getType())
&& isTypeSource(expr, enclosingExpression.getRightExpression())) {
targetType = getDeclaredOrInferredType(enclosingExpression.getLeftExpression());
+ } else if (enclosingMethodCall != null
+ && InvocationWriter.makeArgumentList(enclosingMethodCall.getArguments())
+ .getExpressions().stream().anyMatch(arg -> isTypeSource(expr, arg))) {
+ // TODO: locate method target parameter
} else if (enclosingMethod != null
&& !enclosingMethod.isAbstract()
&& !enclosingMethod.isVoidMethod()
@@ -4327,9 +4330,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
protected void storeType(final Expression exp, ClassNode cn) {
- if (cn == UNKNOWN_PARAMETER_TYPE) {
- // this can happen for example when "null" is used in an assignment or a method parameter.
- // In that case, instead of storing the virtual type, we must "reset" type information
+ if (cn == UNKNOWN_PARAMETER_TYPE) { // null for assignment or parameter
+ // instead of storing an "unknown" type, reset the type information
// by determining the declaration type of the expression
cn = getOriginalDeclarationType(exp);
}
@@ -4692,37 +4694,25 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
return null;
}
- private List<MethodNode> disambiguateMethods(List<MethodNode> methods, final ClassNode receiver, final ClassNode[] argTypes, final Expression call) {
- if (methods.size() > 1 && receiver != null && argTypes != null) {
+ private List<MethodNode> disambiguateMethods(List<MethodNode> methods, final ClassNode receiver, final ClassNode[] arguments, final Expression call) {
+ if (methods.size() > 1 && receiver != null && arguments != null) {
List<MethodNode> filteredWithGenerics = new LinkedList<>();
- for (MethodNode methodNode : methods) {
- if (typeCheckMethodsWithGenerics(receiver, argTypes, methodNode)) {
- if ((methodNode.getModifiers() & Opcodes.ACC_BRIDGE) == 0) {
- filteredWithGenerics.add(methodNode);
- }
+ for (MethodNode method : methods) {
+ if (typeCheckMethodsWithGenerics(receiver, arguments, method)
+ && (method.getModifiers() & Opcodes.ACC_BRIDGE) == 0) {
+ filteredWithGenerics.add(method);
}
}
if (filteredWithGenerics.size() == 1) {
return filteredWithGenerics;
}
+
methods = extension.handleAmbiguousMethods(methods, call);
}
- if (methods.size() > 1) {
- if (call instanceof MethodCall) {
- List<MethodNode> methodNodeList = new LinkedList<>();
-
- String methodName = ((MethodCall) call).getMethodAsString();
-
- for (MethodNode methodNode : methods) {
- if (!methodNode.getName().equals(methodName)) {
- continue;
- }
- methodNodeList.add(methodNode);
- }
-
- methods = methodNodeList;
- }
+ if (methods.size() > 1 && call instanceof MethodCall) {
+ String methodName = ((MethodCall) call).getMethodAsString();
+ methods = methods.stream().filter(m -> m.getName().equals(methodName)).collect(Collectors.toList());
}
return methods;
@@ -4760,9 +4750,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
/**
* Returns methods defined for the specified receiver and adds "non-existing"
* methods that will be generated afterwards by the compiler; for example if
- * a method is using default values and the class node isn't compiled yet.
+ * a method is using default values and the class node is not compiled yet.
*
- * @param receiver the receiver where to find methods
+ * @param receiver the type to search for methods
* @param name the name of the methods to return
* @return the methods that are defined on the receiver completed with stubs for future methods
*/
@@ -4793,10 +4783,11 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
methods.addAll(OBJECT_TYPE.getMethods(name));
}
- if (methods.isEmpty() || receiver.isResolved()) {
- return methods;
+ if (!receiver.isResolved() && !methods.isEmpty()) {
+ methods = addGeneratedMethods(receiver, methods);
}
- return addGeneratedMethods(receiver, methods);
+
+ return methods;
}
private static List<MethodNode> addGeneratedMethods(final ClassNode receiver, final List<MethodNode> methods) {
@@ -4836,7 +4827,6 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
method.getExceptions(),
GENERATED_EMPTY_STATEMENT
);
-
} else {
stubbed = new MethodNode(
method.getName(),
@@ -4918,7 +4908,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
node.setDeclaringClass(property.getDeclaringClass());
return Collections.singletonList(node);
}
- } else if (methods.isEmpty() && args != null && args.length == 1) {
+ } else if (methods.isEmpty() && args.length == 1) {
// maybe we are looking for a setter ?
String pname = extractPropertyNameFromMethodName("set", name);
if (pname != null) {
@@ -5665,8 +5655,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
todo = new ClassNode[] {!isPrimitiveType(declaringClass) ? wrapTypeIfNecessary(receiver) : receiver};
}
for (ClassNode type : todo) {
- ClassNode current = type;
- while (current != null) {
+ for (ClassNode current = type; current != null; ) {
Map<GenericsTypeName, GenericsType> placeHolders = new HashMap<>();
if (current.isGenericsPlaceHolder())
// GROOVY-10622: type param bound "T extends Set<Type>"
@@ -5724,8 +5713,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
result = new HashMap<>();
} else {
ClassNode declaring = method.getDeclaringClass();
- if (argument instanceof ArgumentListExpression) { // resolve extension method class
- List<Expression> arguments = ((ArgumentListExpression) argument).getExpressions();
+ if (argument instanceof TupleExpression) { // resolve extension method class
+ List<Expression> arguments = ((TupleExpression) argument).getExpressions();
if (!arguments.isEmpty()) {
ClassNode cn = arguments.get(0).getNodeMetaData(ExtensionMethodDeclaringClass.class);
if (cn != null)
@@ -5949,10 +5938,10 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
public static class SignatureCodecFactory {
public static SignatureCodec getCodec(final int version, final ClassLoader classLoader) {
switch (version) {
- case 1:
- return new SignatureCodecVersion1(classLoader);
- default:
- return null;
+ case 1:
+ return new SignatureCodecVersion1(classLoader);
+ default:
+ return null;
}
}
}
diff --git a/src/test/groovy/transform/stc/TernaryOperatorSTCTest.groovy b/src/test/groovy/transform/stc/TernaryOperatorSTCTest.groovy
index c8708bccea..3b975d2c4c 100644
--- a/src/test/groovy/transform/stc/TernaryOperatorSTCTest.groovy
+++ b/src/test/groovy/transform/stc/TernaryOperatorSTCTest.groovy
@@ -166,6 +166,55 @@ class TernaryOperatorSTCTest extends StaticTypeCheckingTestCase {
'''
}
+ @NotYetImplemented // GROOVY-10271
+ void testFunctionalInterfaceTarget1() {
+ for (flag in ['true', 'false']) {
+ assertScript """import java.util.function.Supplier
+
+ Supplier<Integer> x = { -> 1 }
+ Supplier<Integer> y = $flag ? x : { -> 2 }
+
+ assert y.get() == ($flag ? 1 : 2)
+ """
+ }
+ }
+
+ @NotYetImplemented // GROOVY-10272
+ void testFunctionalInterfaceTarget2() {
+ assertScript '''
+ import java.util.function.Function
+
+ Function<Integer, Long> x
+ if (true) {
+ x = { a -> a.longValue() }
+ } else {
+ x = { Integer b -> (Long)b }
+ }
+ assert x.apply(42) == 42L
+
+ Function<Integer, Long> y = (true ? { a -> a.longValue() } : { Integer b -> (Long)b })
+ assert y.apply(42) == 42L
+ '''
+ }
+
+ // GROOVY-10701
+ void testFunctionalInterfaceTarget3() {
+ for (type in ['Function<T,T>', 'UnaryOperator<T>']) {
+ assertScript """import java.util.function.*
+
+ def <T> T m1($type x) {
+ x.apply(null)
+ }
+ double m2(double d) {
+ Math.PI
+ }
+
+ def result = m1(true ? (Double d) -> 42.0d : this::m2)
+ assert result == 42.0d
+ """
+ }
+ }
+
// GROOVY-10357
void testAbstractMethodDefault() {
assertScript '''