daniellansun commented on code in PR #3293:
URL: https://github.com/apache/groovy/pull/3293#discussion_r4573655350
##########
src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java:
##########
@@ -1950,9 +2083,20 @@ private static boolean
typeCheckMethodsWithGenerics(final ClassNode receiver, fi
// that are not containment errors.
if (!GenericsUtils.hasUnresolvedGenerics(parameterType)
&& !GenericsUtils.hasUnresolvedGenerics(argumentType)
- && concreteArgumentContainsWildcard(parameterType,
argumentType)) {
+ && (concreteArgumentContainsWildcard(parameterType,
argumentType)
+ || upperBoundEscapes(parameterType, argumentType))) {
failure = true;
}
+ // a parameter typed by type variables in scope, not by the
method's own, is checked as an assignment;
+ // take its type before the argument is used to infer anything
+ if (!failure && !skipBecauseOfInnerClassNotReceiver &&
!isRawReceiver(receiver) && !isDiamondReceiver(receiver)
+ && !mentionsTypeParameterOf(parameterType,
candidateMethod)) {
+ ClassNode resolvedType =
applyGenericsContext(candidateGenerics, parameterType);
+ if (GenericsUtils.hasUnresolvedGenerics(resolvedType) &&
!GenericsUtils.hasUnresolvedGenerics(argumentType)
Review Comment:
Two gaps in `StaticTypeCheckingSupport`:
1. **Concretely parameterized receivers (`typeCheckMethodsWithGenerics`):**
For a call like `map.put('k', rawClassExtendsList)` on `Map<String, Class<?
extends List<String>>>` (or `box.set(...)` on `Box<Class<? extends
List<Number>>>`), the first `if` is skipped because `parameterType` (`V` / `T`)
has unresolved generics, and this second `if` is also skipped because
`resolvedType` (`Class<? extends List<String>>`) no longer has unresolved
generics. Dropping the `hasUnresolvedGenerics(resolvedType)` guard on
`upperBoundEscapes` and checking
`concreteArgumentContainsWildcard(resolvedType, argumentType)` when
`!GenericsUtils.hasUnresolvedGenerics(resolvedType)` closes that gap.
2. **`compatibleCapture` / `captureWithinBound`:**
- In `captureWithinBound`, `captureBounds` is an intersection (`glb`), so
returning `false` on the first `captureBound` whose raw type implements `bound`
skips remaining bounds in the intersection (e.g. `NumBox<? extends List<?>>`
for `class NumBox<C extends Collection<Number>> {}` fails on `List<?>` before
checking `Collection<Number>`, whereas `javac` accepts it). Only a matching
bound should `return true`; non-matching components should `continue`.
-
`GenericsUtils.buildWildcardType(target).isCompatibleWith(captureBound)` in
`captureWithinBound` also needs `&& !concreteArgumentContainsWildcard(target,
captureBound) && !upperBoundEscapes(target, captureBound)`.
- In `compatibleCapture`,
`isObjectType(capture.getUnresolvedSuperClass())` keeps the first class bound
(e.g. `Number`) and drops a narrower declared class bound (e.g. `Integer`);
refining whenever `bound.isDerivedFrom(capture.getUnresolvedSuperClass())`
preserves the narrower bound.
##########
src/main/java/org/codehaus/groovy/control/ResolveVisitor.java:
##########
@@ -453,6 +462,102 @@ private void resolveOrFail(final ClassNode type, final
String msg, final ASTNode
addError("unable to resolve class " + type.toString(false) + msg,
node);
}
+ /**
+ * JLS 6.5.5.1, 8.1.3, 8.5: within {@code Outer<T>}, the simple name
{@code Inner}
+ * of an inner class is the type {@code Outer<T>.Inner}, and within a
subclass that
+ * extends {@code Outer<String>} it is {@code Outer<String>.Inner}.
Neither is the
+ * raw type {@code Outer.Inner}. Records the enclosing type for such a
name. A name
+ * used where the type variables are out of scope, as in a static method,
stays raw.
+ */
+ private void setOuterClassTypeOfSimpleName(ClassNode type) {
+ while (type.isArray()) type = type.getComponentType();
+ if (!type.isRedirectNode() || type.isGenericsPlaceHolder() ||
type.getOuterClassType() != null) return;
+ String name = type.getUnresolvedName();
+ if (name.indexOf('.') != -1 || name.indexOf('$') != -1) return; //
Outer.Inner is the raw type
+ ClassNode inner = type.redirect(), outer = inner.getOuterClass();
+ if (outer == null || isStaticMember(inner)) return;
+ if (type.getGenericsTypes() == null && inner.getGenericsTypes() !=
null) return; // raw type
+
+ for (ClassNode cn = currentClass; cn != null; cn = cn.getOuterClass())
{
+ boolean declares = cn.equals(outer);
+ if (declares || inherits(cn, outer)) {
+ ClassNode outerType = typeOfThis(cn);
+ if (outerType != null && !declares) {
+ outerType = GenericsUtils.parameterizeType(outerType,
outer);
+ }
+ if (outerType != null && (outerType.getOuterClassType() != null
+ || (outerType.isRedirectNode() &&
outerType.getGenericsTypes() != null))) {
+ type.setOuterClassType(outerType);
+ }
+ return;
+ }
+ if (isRecord(cn)) return; // the type variables of its enclosing
classes are out of scope
Review Comment:
Within `class Sub extends Outer<String>` (where `Outer<String>` has no type
variables), static nested declarations currently resolve the simple name
`Inner` inconsistently:
- `static class Nested { Inner f }` walks past `Nested` to `Sub`,
`typeOfThis(Sub)` returns `Sub`, and `f` gets `Outer<String>.Inner` (matching
`javac`).
- `record Rec(Inner f) {}` stops at `if (isRecord(cn)) return;` on `Rec`
before reaching `Sub`, so `f` stays raw `Outer.Inner`.
- `class Sub<U> extends Outer<String> { static class Nested { Inner f } }`
fails `typeOfThis(Sub)` because `U` is out of scope in `Nested`, even though
`Outer<String>` does not mention `U`, so `f` also falls back to raw
`Outer.Inner`.
Per JLS §6.5.5 and §8.5, an inherited member type `Outer<String>.Inner` does
not depend on an enclosing instance or on `U`; only an `outerType` that still
references an out-of-scope type variable needs to be rejected/left raw.
##########
src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java:
##########
@@ -2244,16 +2251,203 @@ private void checkTypeGenerics(final ClassNode
leftExpressionType, final ClassNo
return;
}
ClassNode right = wrapTypeIfNecessary(rightExpressionType);
+ if (hasIncompatibleGenerics(leftExpressionType, right)) {
+ if (isTypedByTarget(leftExpressionType, right, rightExpression)) {
+ rightExpression.setNodeMetaData(TARGET_TYPED,
leftExpressionType); // the expression has the type of its target
+ } else {
+ addStaticTypeError("Incompatible generic argument types.
Cannot assign " + prettyPrintType(rightExpressionType) + " to: " +
prettyPrintType(leftExpressionType), rightExpression);
+ }
+ }
+ }
+
+ private static boolean hasIncompatibleGenerics(final ClassNode targetType,
final ClassNode type) {
// A type variable is not "missing" generics: its bound is known.
// Raw types and uninferred diamonds still skip the check.
- boolean unresolved = missesGenericsTypes(right);
+ boolean unresolved = missesGenericsTypes(type);
boolean incompatible = !unresolved && (
-
!GenericsUtils.buildWildcardType(leftExpressionType).isCompatibleWith(right)
- || concreteArgumentContainsWildcard(leftExpressionType,
right));
- boolean typeVariableEscapes = unresolved &&
(typeVariableBoundEscapes(leftExpressionType, right)
- || concreteArgumentContainsWildcard(leftExpressionType,
right));
- if (incompatible || typeVariableEscapes) {
- addStaticTypeError("Incompatible generic argument types. Cannot
assign " + prettyPrintType(rightExpressionType) + " to: " +
prettyPrintType(leftExpressionType), rightExpression);
+
!GenericsUtils.buildWildcardType(targetType).isCompatibleWith(type)
+ || concreteArgumentContainsWildcard(targetType, type)
+ || typeVariableArgumentGetsWildcard(targetType, type)
+ || upperBoundEscapes(targetType, type));
+ boolean typeVariableEscapes = unresolved &&
(typeVariableBoundEscapes(targetType, type)
+ || concreteArgumentContainsWildcard(targetType, type)
+ || upperBoundEscapes(targetType, type));
+ return incompatible || typeVariableEscapes;
+ }
+
+ /**
+ * Whether an expression whose own type does not fit the target is typed
by the target:
+ * a call of a generic method or a spread expression, in an assignment or
return context.
+ */
+ private boolean isTypedByTarget(final ClassNode targetType, final
ClassNode type, final Expression expression) {
+ return isApplicableForTargetType(targetType, expression)
+ || isSpreadApplicableForTargetType(targetType, type,
expression);
+ }
+
+ /**
+ * A spread expression such as {@code list*.getClass()} or {@code
list*.name} makes a new
+ * list, so in an assignment or return context its element type is taken
from the target,
+ * as it is for {@code list.collect { it.getClass() }}. The expression is
accepted when the
+ * type of its elements fits the type argument of the target.
+ */
+ private boolean isSpreadApplicableForTargetType(final ClassNode
targetType, final ClassNode spreadType, final Expression expression) {
+ boolean spread = expression instanceof MethodCallExpression ?
((MethodCallExpression) expression).isSpreadSafe()
+ : expression instanceof PropertyExpression &&
((PropertyExpression) expression).isSpreadSafe();
+ if (!spread || !LIST_TYPE.equals(spreadType)) return false;
+ GenericsType[] elementTypes = spreadType.getGenericsTypes();
+ if (elementTypes == null || elementTypes.length != 1 ||
elementTypes[0].isWildcard() || elementTypes[0].isPlaceholder()) return false;
+ if (!LIST_TYPE.equals(targetType) &&
!implementsInterfaceOrIsSubclassOf(LIST_TYPE, targetType)) return false;
+
+ ClassNode declared = LIST_TYPE.redirect();
+ ClassNode viewed = LIST_TYPE.equals(targetType) ? declared :
GenericsUtils.parameterizeType(declared, targetType);
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ extractGenericsConnections(connections, targetType, viewed);
+ GenericsType expected = connections.get(new
GenericsTypeName(declared.getGenericsTypes()[0].getName()));
+ if (expected == null || expected.isWildcard() ||
expected.isPlaceholder()) return false;
+
+ return typeCheckMethodArgumentWithGenerics(expected.getType(),
wrapTypeIfNecessary(elementTypes[0].getType()), false);
Review Comment:
`typeCheckMethodArgumentWithGenerics` alone does not enforce
`upperBoundEscapes`, `concreteArgumentContainsWildcard`, or
`typeVariableArgumentGetsWildcard`. As a result, spread target-typing bypasses
the `t.getClass()` and raw-bound checks that direct assignment rejects:
```groovy
@groovy.transform.CompileStatic
static <T> List<Class<? extends T>> classesOf(List<T> items) {
List<Class<? extends T>> res = items*.getClass() // accepted, should be
rejected
res
}
@groovy.transform.CompileStatic
static List<Class<? extends List<String>>> rawSpread(List<List> rawLists) {
List<Class<? extends List<String>>> res = rawLists*.getClass() //
accepted, should be rejected
res
}
```
Checking `!hasIncompatibleGenerics(expected.getType(), actualElement)`
alongside `typeCheckMethodArgumentWithGenerics` closes this gap.
##########
src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java:
##########
@@ -3637,6 +3834,14 @@ protected ClassNode checkReturnType(final
ReturnStatement statement) {
if (expression instanceof ConstructorCallExpression) {
inferDiamondType((ConstructorCallExpression) expression,
inferredReturnType != null ? inferredReturnType :
/*GROOVY-10080:*/dynamicType());
}
+ if (inferredReturnType != null
+ && inferredReturnType.equals(type)
Review Comment:
Thanks for adding `e72bb7a`. Requiring `inferredReturnType.equals(type)`
here checks raw class equality, whereas `isApplicableForTargetType` and
`isSpreadApplicableForTargetType` support supertype targets
(`implementsInterfaceOrIsSubclassOf`). As a result, a supertype target on
`Closure<V>` still fails on the closure return:
```groovy
static Collection<Class<?>> closureSuperTarget(String x) {
Closure<Collection<Class<?>>> c = { String s ->
Collections.singletonList(s.getClass()) }
c.call(x) // fails: Cannot return value of type List<Class<? extends
String>> for closure expecting Collection<Class<?>>
}
```
Relaxing `inferredReturnType.equals(type)` to
`implementsInterfaceOrIsSubclassOf(wrapTypeIfNecessary(type),
inferredReturnType)` fixes this. Also note the `allow simple covariance` branch
right below: when `!inferredReturnType.equals(type)` (e.g. returning
`ArrayList<Class<? extends List>>` for `List<Class<? extends List<String>>>`),
`isCompatibleWith` runs without `!hasIncompatibleGenerics(inferredReturnType,
wrapTypeIfNecessary(type))`.
Two minor `IntersectionTypeClassNode` points in this file as well:
- **`getResultType` (`!isClassType(right)`):** After `Serializable s =
String.class; if (s instanceof Class)`, `right` is
`IntersectionTypeClassNode(Serializable & Class)`, so `isClassType(right)` is
`false` and `Class<? extends Number> c = s` is accepted as a non-`Class`
conversion. Using `!implementsInterfaceOrIsSubclassOf(right, CLASS_Type)`
handles intersections with `Class`.
- **`erasureOf` (`intersection.getComponents()[0]`):** Taking
`components[0]` depends on declaration order in `instanceof` narrowing: for
`Comparable c = 42; if (c instanceof Number)`, `components[0]` is `Comparable`,
so `Class<? extends Number> cls = c.getClass()` is rejected inside the
`instanceof Number` branch. Preferring a non-`Object` class component ahead of
interfaces matches JLS §4.4 and §4.6.
##########
src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java:
##########
@@ -2244,16 +2251,203 @@ private void checkTypeGenerics(final ClassNode
leftExpressionType, final ClassNo
return;
}
ClassNode right = wrapTypeIfNecessary(rightExpressionType);
+ if (hasIncompatibleGenerics(leftExpressionType, right)) {
+ if (isTypedByTarget(leftExpressionType, right, rightExpression)) {
+ rightExpression.setNodeMetaData(TARGET_TYPED,
leftExpressionType); // the expression has the type of its target
+ } else {
+ addStaticTypeError("Incompatible generic argument types.
Cannot assign " + prettyPrintType(rightExpressionType) + " to: " +
prettyPrintType(leftExpressionType), rightExpression);
+ }
+ }
+ }
+
+ private static boolean hasIncompatibleGenerics(final ClassNode targetType,
final ClassNode type) {
// A type variable is not "missing" generics: its bound is known.
// Raw types and uninferred diamonds still skip the check.
- boolean unresolved = missesGenericsTypes(right);
+ boolean unresolved = missesGenericsTypes(type);
boolean incompatible = !unresolved && (
-
!GenericsUtils.buildWildcardType(leftExpressionType).isCompatibleWith(right)
- || concreteArgumentContainsWildcard(leftExpressionType,
right));
- boolean typeVariableEscapes = unresolved &&
(typeVariableBoundEscapes(leftExpressionType, right)
- || concreteArgumentContainsWildcard(leftExpressionType,
right));
- if (incompatible || typeVariableEscapes) {
- addStaticTypeError("Incompatible generic argument types. Cannot
assign " + prettyPrintType(rightExpressionType) + " to: " +
prettyPrintType(leftExpressionType), rightExpression);
+
!GenericsUtils.buildWildcardType(targetType).isCompatibleWith(type)
+ || concreteArgumentContainsWildcard(targetType, type)
+ || typeVariableArgumentGetsWildcard(targetType, type)
+ || upperBoundEscapes(targetType, type));
+ boolean typeVariableEscapes = unresolved &&
(typeVariableBoundEscapes(targetType, type)
+ || concreteArgumentContainsWildcard(targetType, type)
+ || upperBoundEscapes(targetType, type));
+ return incompatible || typeVariableEscapes;
+ }
+
+ /**
+ * Whether an expression whose own type does not fit the target is typed
by the target:
+ * a call of a generic method or a spread expression, in an assignment or
return context.
+ */
+ private boolean isTypedByTarget(final ClassNode targetType, final
ClassNode type, final Expression expression) {
+ return isApplicableForTargetType(targetType, expression)
+ || isSpreadApplicableForTargetType(targetType, type,
expression);
+ }
+
+ /**
+ * A spread expression such as {@code list*.getClass()} or {@code
list*.name} makes a new
+ * list, so in an assignment or return context its element type is taken
from the target,
+ * as it is for {@code list.collect { it.getClass() }}. The expression is
accepted when the
+ * type of its elements fits the type argument of the target.
+ */
+ private boolean isSpreadApplicableForTargetType(final ClassNode
targetType, final ClassNode spreadType, final Expression expression) {
+ boolean spread = expression instanceof MethodCallExpression ?
((MethodCallExpression) expression).isSpreadSafe()
+ : expression instanceof PropertyExpression &&
((PropertyExpression) expression).isSpreadSafe();
+ if (!spread || !LIST_TYPE.equals(spreadType)) return false;
+ GenericsType[] elementTypes = spreadType.getGenericsTypes();
+ if (elementTypes == null || elementTypes.length != 1 ||
elementTypes[0].isWildcard() || elementTypes[0].isPlaceholder()) return false;
+ if (!LIST_TYPE.equals(targetType) &&
!implementsInterfaceOrIsSubclassOf(LIST_TYPE, targetType)) return false;
+
+ ClassNode declared = LIST_TYPE.redirect();
+ ClassNode viewed = LIST_TYPE.equals(targetType) ? declared :
GenericsUtils.parameterizeType(declared, targetType);
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ extractGenericsConnections(connections, targetType, viewed);
+ GenericsType expected = connections.get(new
GenericsTypeName(declared.getGenericsTypes()[0].getName()));
+ if (expected == null || expected.isWildcard() ||
expected.isPlaceholder()) return false;
+
+ return typeCheckMethodArgumentWithGenerics(expected.getType(),
wrapTypeIfNecessary(elementTypes[0].getType()), false);
+ }
+
+ /**
+ * A call of a generic method in an assignment or return context takes its
type arguments
+ * from the target type as well as from the arguments (JLS 18.5.2), so that
+ * {@code List<Class<?>> list = Collections.singletonList(x.getClass())}
is accepted although
+ * the arguments alone give {@code List<Class<? extends String>>}. The
call is accepted when
+ * the type parameters that the target determines keep their bounds and
every argument fits
+ * its parameter with them.
+ */
+ private boolean isApplicableForTargetType(final ClassNode targetType,
final Expression call) {
+ if (!(call instanceof MethodCall) || (call instanceof
MethodCallExpression && ((MethodCallExpression) call).isUsingGenerics()))
return false;
+ MethodNode method = call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+ if (method == null) return false;
+ List<ClassNode> argumentTypes = new ArrayList<>();
+ List<Expression> arguments = new
ArrayList<>(InvocationWriter.makeArgumentList(((MethodCall)
call).getArguments()).getExpressions());
+ if (method instanceof ExtensionMethodNode) {
+ if (!(call instanceof MethodCallExpression)) return false;
+ Expression receiver = ((MethodCallExpression)
call).getObjectExpression();
+ method = ((ExtensionMethodNode) method).getExtensionMethodNode();
+ arguments.add(0, receiver);
+ }
+ GenericsType[] typeParameters = method.getGenericsTypes();
+ ClassNode returnType = method.getReturnType();
+ if (typeParameters == null || typeParameters.length == 0 ||
!GenericsUtils.hasUnresolvedGenerics(returnType)) return false;
+ Set<String> names = new HashSet<>();
+ for (GenericsType tp : typeParameters) names.add(tp.getName());
+ // only the type parameters of the method may take their type from the
target
+ Set<String> used = new HashSet<>();
+ collectTypeVariableNames(returnType, used);
+ if (!names.containsAll(used)) return false;
+
+ ClassNode viewed = returnType;
+ if (!returnType.equals(targetType)) {
+ if (!implementsInterfaceOrIsSubclassOf(returnType, targetType))
return false;
+ viewed = GenericsUtils.parameterizeType(returnType, targetType);
+ }
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ extractGenericsConnections(connections, targetType, viewed);
+ connections.keySet().removeIf(name -> !names.contains(name.getName()));
+ for (Map.Entry<GenericsTypeName, GenericsType> entry :
connections.entrySet()) {
+ GenericsType value = entry.getValue();
+ if (value.isWildcard()) { // take "? extends B" or "? super B" as B
+ ClassNode bound = value.getLowerBound() != null ?
value.getLowerBound()
+ : value.getUpperBounds() != null ?
value.getUpperBounds()[0] : OBJECT_TYPE;
+ entry.setValue(bound.asGenericsType());
+ }
+ }
+ if (connections.isEmpty()) return false;
+
+ for (GenericsType tp : typeParameters) { // the target must keep each
type parameter within its bounds
+ GenericsType value = connections.get(new
GenericsTypeName(tp.getName()));
+ if (value == null || tp.getUpperBounds() == null) continue;
+ for (ClassNode bound : applyGenericsContext(connections,
tp.getUpperBounds())) {
+ if (GenericsUtils.hasUnresolvedGenerics(bound) ?
!isAssignableTo(value.getType(), bound)
+ : !typeCheckMethodArgumentWithGenerics(bound,
value.getType(), false)) return false;
+ }
+ }
+
+ Parameter[] parameters = method.getParameters();
+ int n = arguments.size();
+ if (parameters.length == 0 || (n != parameters.length &&
!isVargs(parameters))) return false;
+ for (int i = 0; i < n; i += 1) {
+ Expression argument = arguments.get(i);
+ ClassNode parameterType = parameters[Math.min(i, parameters.length
- 1)].getOriginType();
+ if (!GenericsUtils.hasUnresolvedGenerics(parameterType)) continue;
+ boolean lastArg = i >= parameters.length - 1;
+ if (lastArg && parameterType.isArray() && (n != parameters.length
|| !getType(argument).isArray())) {
+ parameterType = parameterType.getComponentType();
+ }
+ parameterType = applyGenericsContext(connections, parameterType);
+ if (isNullConstant(argument)) continue;
+ if (argument instanceof ClosureExpression || argument instanceof
LambdaExpression || argument instanceof MethodPointerExpression) {
+ // a closure or lambda must return what the parameterized
target expects
+ ClassNode expected = null;
+ if (CLOSURE_TYPE.equals(parameterType)) {
+ GenericsType[] gts = parameterType.getGenericsTypes();
+ if (gts != null && gts.length == 1) expected =
getCombinedBoundType(gts[0]);
+ } else if (isSAMType(parameterType)) {
+ expected =
GenericsUtils.parameterizeSAM(parameterType).getV2();
+ }
+ ClassNode actual = getInferredReturnType(argument);
+ if (expected == null || actual == null ||
GenericsUtils.hasUnresolvedGenerics(expected)) continue;
Review Comment:
Four soundness issues across this parameter loop (plus an unused
`List<ClassNode> argumentTypes` local at the top of
`isApplicableForTargetType`):
1. **Fail-open `continue` on unhandled functional arguments:**
`isApplicableForTargetType` rescues an assignment that already failed
`hasIncompatibleGenerics`, so unhandled cases must `return false`, not
`continue`:
- `visitMethodPointerExpression` stores `Closure<R>` via `storeType` and
never sets `INFERRED_RETURN_TYPE`, so `actual` is `null` and `List<Integer>
ints = ['a'].collect(String::toUpperCase)` compiles under `@CompileStatic`.
- When `expected` mentions an enclosing type variable `T`,
`hasUnresolvedGenerics(expected)` is `true`, so `<T> List<T> cast(List<String>
s) { List<T> r = s.collect { String x -> x }; r }` compiles under
`@CompileStatic`.
2. **SAM and closure parameter types are not checked against
`connections`:** `parameterizeSAM(parameterType)` inspects only `.getV2()`
(return type) and ignores `.getV1()` (parameter types):
```groovy
import java.util.function.Consumer
import java.util.function.Function
static <T> Consumer<T> toConsumer(Function<T, Object> fn) {
(T t) -> fn.apply(t)
}
static void test() {
Consumer<Object> c = toConsumer((String s) -> s.length())
c.accept(1) // ClassCastException: Integer cannot be cast to String
}
```
3. **Missing escape checks on closure return (`expected` vs `actual`):**
`isCompatibleWith` alone misses `concreteArgumentContainsWildcard`,
`typeVariableArgumentGetsWildcard`, and `upperBoundEscapes` (e.g. `List<Class<?
extends List<String>>> r = rawClassList.collect { it }`). Calling
`hasIncompatibleGenerics(wrapTypeIfNecessary(expected), actual)` covers all
three.
4. **Enclosing type variables in
`GenericsUtils.hasUnresolvedGenerics(parameterType)`:**
`hasUnresolvedGenerics(parameterType)` is also `true` when `connections`
substituted an enclosing type variable `U` from `targetType`. Falling back to
`isAssignableTo` skips `typeVariableArgumentGetsWildcard` and
`upperBoundEscapes`, bypassing `GROOVY-12755`:
```groovy
static <U> Class<? extends U> bypassClassOf(U u) {
List<Class<? extends U>> box = Collections.singletonList(u.getClass())
box[0]
}
static <U extends Number> Class<? extends U> bypassBound(Class<? extends
Number> c) {
List<Class<? extends U>> box = Collections.singletonList(c)
box[0]
}
```
Please check `mentionsTypeParameterOf(parameterType, method)` for
undetermined method type parameters, and run
`!hasIncompatibleGenerics(parameterType, argumentType)` when enclosing type
variables are present.
##########
src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java:
##########
@@ -2244,16 +2251,203 @@ private void checkTypeGenerics(final ClassNode
leftExpressionType, final ClassNo
return;
}
ClassNode right = wrapTypeIfNecessary(rightExpressionType);
+ if (hasIncompatibleGenerics(leftExpressionType, right)) {
+ if (isTypedByTarget(leftExpressionType, right, rightExpression)) {
+ rightExpression.setNodeMetaData(TARGET_TYPED,
leftExpressionType); // the expression has the type of its target
+ } else {
+ addStaticTypeError("Incompatible generic argument types.
Cannot assign " + prettyPrintType(rightExpressionType) + " to: " +
prettyPrintType(leftExpressionType), rightExpression);
+ }
+ }
+ }
+
+ private static boolean hasIncompatibleGenerics(final ClassNode targetType,
final ClassNode type) {
// A type variable is not "missing" generics: its bound is known.
// Raw types and uninferred diamonds still skip the check.
- boolean unresolved = missesGenericsTypes(right);
+ boolean unresolved = missesGenericsTypes(type);
boolean incompatible = !unresolved && (
-
!GenericsUtils.buildWildcardType(leftExpressionType).isCompatibleWith(right)
- || concreteArgumentContainsWildcard(leftExpressionType,
right));
- boolean typeVariableEscapes = unresolved &&
(typeVariableBoundEscapes(leftExpressionType, right)
- || concreteArgumentContainsWildcard(leftExpressionType,
right));
- if (incompatible || typeVariableEscapes) {
- addStaticTypeError("Incompatible generic argument types. Cannot
assign " + prettyPrintType(rightExpressionType) + " to: " +
prettyPrintType(leftExpressionType), rightExpression);
+
!GenericsUtils.buildWildcardType(targetType).isCompatibleWith(type)
+ || concreteArgumentContainsWildcard(targetType, type)
+ || typeVariableArgumentGetsWildcard(targetType, type)
+ || upperBoundEscapes(targetType, type));
+ boolean typeVariableEscapes = unresolved &&
(typeVariableBoundEscapes(targetType, type)
+ || concreteArgumentContainsWildcard(targetType, type)
+ || upperBoundEscapes(targetType, type));
+ return incompatible || typeVariableEscapes;
+ }
+
+ /**
+ * Whether an expression whose own type does not fit the target is typed
by the target:
+ * a call of a generic method or a spread expression, in an assignment or
return context.
+ */
+ private boolean isTypedByTarget(final ClassNode targetType, final
ClassNode type, final Expression expression) {
+ return isApplicableForTargetType(targetType, expression)
+ || isSpreadApplicableForTargetType(targetType, type,
expression);
+ }
+
+ /**
+ * A spread expression such as {@code list*.getClass()} or {@code
list*.name} makes a new
+ * list, so in an assignment or return context its element type is taken
from the target,
+ * as it is for {@code list.collect { it.getClass() }}. The expression is
accepted when the
+ * type of its elements fits the type argument of the target.
+ */
+ private boolean isSpreadApplicableForTargetType(final ClassNode
targetType, final ClassNode spreadType, final Expression expression) {
+ boolean spread = expression instanceof MethodCallExpression ?
((MethodCallExpression) expression).isSpreadSafe()
+ : expression instanceof PropertyExpression &&
((PropertyExpression) expression).isSpreadSafe();
+ if (!spread || !LIST_TYPE.equals(spreadType)) return false;
+ GenericsType[] elementTypes = spreadType.getGenericsTypes();
+ if (elementTypes == null || elementTypes.length != 1 ||
elementTypes[0].isWildcard() || elementTypes[0].isPlaceholder()) return false;
+ if (!LIST_TYPE.equals(targetType) &&
!implementsInterfaceOrIsSubclassOf(LIST_TYPE, targetType)) return false;
+
+ ClassNode declared = LIST_TYPE.redirect();
+ ClassNode viewed = LIST_TYPE.equals(targetType) ? declared :
GenericsUtils.parameterizeType(declared, targetType);
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ extractGenericsConnections(connections, targetType, viewed);
+ GenericsType expected = connections.get(new
GenericsTypeName(declared.getGenericsTypes()[0].getName()));
+ if (expected == null || expected.isWildcard() ||
expected.isPlaceholder()) return false;
+
+ return typeCheckMethodArgumentWithGenerics(expected.getType(),
wrapTypeIfNecessary(elementTypes[0].getType()), false);
+ }
+
+ /**
+ * A call of a generic method in an assignment or return context takes its
type arguments
+ * from the target type as well as from the arguments (JLS 18.5.2), so that
+ * {@code List<Class<?>> list = Collections.singletonList(x.getClass())}
is accepted although
+ * the arguments alone give {@code List<Class<? extends String>>}. The
call is accepted when
+ * the type parameters that the target determines keep their bounds and
every argument fits
+ * its parameter with them.
+ */
+ private boolean isApplicableForTargetType(final ClassNode targetType,
final Expression call) {
+ if (!(call instanceof MethodCall) || (call instanceof
MethodCallExpression && ((MethodCallExpression) call).isUsingGenerics()))
return false;
+ MethodNode method = call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+ if (method == null) return false;
+ List<ClassNode> argumentTypes = new ArrayList<>();
+ List<Expression> arguments = new
ArrayList<>(InvocationWriter.makeArgumentList(((MethodCall)
call).getArguments()).getExpressions());
+ if (method instanceof ExtensionMethodNode) {
+ if (!(call instanceof MethodCallExpression)) return false;
+ Expression receiver = ((MethodCallExpression)
call).getObjectExpression();
+ method = ((ExtensionMethodNode) method).getExtensionMethodNode();
+ arguments.add(0, receiver);
+ }
+ GenericsType[] typeParameters = method.getGenericsTypes();
+ ClassNode returnType = method.getReturnType();
+ if (typeParameters == null || typeParameters.length == 0 ||
!GenericsUtils.hasUnresolvedGenerics(returnType)) return false;
+ Set<String> names = new HashSet<>();
+ for (GenericsType tp : typeParameters) names.add(tp.getName());
+ // only the type parameters of the method may take their type from the
target
+ Set<String> used = new HashSet<>();
+ collectTypeVariableNames(returnType, used);
+ if (!names.containsAll(used)) return false;
+
+ ClassNode viewed = returnType;
+ if (!returnType.equals(targetType)) {
+ if (!implementsInterfaceOrIsSubclassOf(returnType, targetType))
return false;
+ viewed = GenericsUtils.parameterizeType(returnType, targetType);
+ }
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ extractGenericsConnections(connections, targetType, viewed);
+ connections.keySet().removeIf(name -> !names.contains(name.getName()));
+ for (Map.Entry<GenericsTypeName, GenericsType> entry :
connections.entrySet()) {
+ GenericsType value = entry.getValue();
+ if (value.isWildcard()) { // take "? extends B" or "? super B" as B
+ ClassNode bound = value.getLowerBound() != null ?
value.getLowerBound()
+ : value.getUpperBounds() != null ?
value.getUpperBounds()[0] : OBJECT_TYPE;
+ entry.setValue(bound.asGenericsType());
Review Comment:
Collapsing a wildcard in `connections` to its bound `B` is only sound if the
instantiated return type `applyGenericsContext(connections, returnType)` is
still compatible with `targetType` (JLS §18.5 `⟨Rθ → T⟩`). Because
`isApplicableForTargetType` returns `true` without checking the substituted
return type against `targetType`, any method where `T` appears inside an
invariant nested generic allows unsound variance widening and heap pollution
under `@CompileStatic`:
```groovy
@groovy.transform.CompileStatic
class NestedWildcardTargetTest {
static <T> List<List<T>> same(List<List<T>> x) { x }
static void test() {
List<List<Integer>> intsOnly = [new ArrayList<Integer>([42])]
List<List<? super Integer>> widened = same(intsOnly) // T -> ? super
Integer -> Integer
widened.add(new ArrayList<Object>(['boom']))
Integer i = intsOnly[1][0] // ClassCastException: String cannot be
cast to Integer
}
}
```
Before returning `true`, please verify that `ClassNode instantiatedReturn =
applyGenericsContext(connections, returnType)` is assignable to `targetType`
and `!hasIncompatibleGenerics(targetType,
wrapTypeIfNecessary(instantiatedReturn))`.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]