[ 
https://issues.apache.org/jira/browse/GROOVY-12754?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18145385#comment-18145385
 ] 

ASF GitHub Bot commented on GROOVY-12754:
-----------------------------------------

daniellansun commented on code in PR #3293:
URL: https://github.com/apache/groovy/pull/3293#discussion_r4580598528


##########
src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java:
##########
@@ -3927,18 +4235,67 @@ private IntPredicate functorArity(final 
MethodPointerExpression pointer) {
         }
         if (methods.isEmpty()) return null;
 
-        BitSet counts = new BitSet();
-        int varargsFrom = Integer.MAX_VALUE;
+        List<FunctorSignature> signatures = new ArrayList<>(methods.size());
         for (MethodNode method : methods) {
-            Parameter[] parameters = method.getParameters();
-            int count = parameters.length + (typeReceiver && 
!method.isStatic() ? 1 : 0);
-            counts.set(count);
-            if (parameters.length > 0 && parameters[parameters.length - 
1].getType().isArray()) {
-                varargsFrom = Math.min(varargsFrom, count - 1);
+            ClassNode[] parameterTypes = 
extractTypesFromParameters(method.getParameters());
+            boolean varargs = parameterTypes.length > 0 && 
parameterTypes[parameterTypes.length - 1].isArray();
+            if (typeReceiver && !method.isStatic()) {
+                ClassNode[] withReceiver = new ClassNode[parameterTypes.length 
+ 1];
+                withReceiver[0] = receiverType;
+                System.arraycopy(parameterTypes, 0, withReceiver, 1, 
parameterTypes.length);
+                parameterTypes = withReceiver;
             }
+            signatures.add(new FunctorSignature(parameterTypes, varargs));
         }
-        int fromVarargs = varargsFrom;
-        return n -> n >= fromVarargs || counts.get(n);
+        return signatures;
+    }
+
+    /**
+     * The parameter types a method reference or pointer can be called with, 
and whether the
+     * last is a varargs parameter.
+     */
+    private record FunctorSignature(ClassNode[] parameterTypes, boolean 
varargs) {
+        /**
+         * The type of the parameter that takes argument {@code i} of {@code 
argumentTypes}:
+         * the component type of a varargs parameter, unless one array is 
given for it.
+         */
+        ClassNode parameterTypeFor(final int i, final ClassNode[] 
argumentTypes) {
+            int count = parameterTypes.length;
+            ClassNode parameterType = parameterTypes[Math.min(i, count - 1)];
+            if (varargs && i >= count - 1 && !(argumentTypes.length == count
+                    && argumentTypes[i] != null && 
argumentTypes[i].isArray())) {
+                parameterType = parameterType.getComponentType();
+            }
+            return parameterType;
+        }
+    }
+
+    /**
+     * Returns the methods a method reference or pointer names that can be 
called with the
+     * parameter types of a SAM: they take that many arguments, and each SAM 
parameter type is
+     * assignable to the method's parameter, or to the component type of its 
varargs parameter.
+     * A parameter type that is not resolved, on either side, is not checked. 
Returns
+     * {@code null} if the functor's methods are not known.
+     */
+    private List<FunctorSignature> fittingSignatures(final 
MethodPointerExpression pointer, final ClassNode[] samParameterTypes) {
+        List<FunctorSignature> signatures = functorSignatures(pointer);
+        if (signatures == null) return null;
+        int n = samParameterTypes.length;
+        List<FunctorSignature> fitting = new ArrayList<>();
+        for (FunctorSignature functor : signatures) {
+            int count = functor.parameterTypes().length;
+            if (n != count && !(functor.varargs() && n >= count - 1)) continue;
+            boolean fits = true;
+            for (int i = 0; i < n && fits; i += 1) {
+                ClassNode samParameterType = samParameterTypes[i];
+                ClassNode parameterType = functor.parameterTypeFor(i, 
samParameterTypes);
+                if (samParameterType == null || 
GenericsUtils.hasUnresolvedGenerics(samParameterType)
+                        || GenericsUtils.hasUnresolvedGenerics(parameterType)) 
continue;

Review Comment:
   A parameter type that the target leaves unresolved is right not to check. 
When it is the referenced method's parameter that is still a type variable, 
though, this `continue` also skips a bound that is already known, so a target 
of `Consumer<String>` accepts `<T extends Number> void takeNumber(T t)` and the 
consumer then fails at run time (`ClassCastException` under `@CompileStatic`). 
`javac` rejects the equivalent, and current master rejects the same Groovy 
programme. A method whose parameter is already a `Number` is rejected here. 
Would it be possible to instantiate the method's type parameters from the SAM — 
as just below, when exactly one method fits — and then check the parameters, 
including that bound?



##########
src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java:
##########
@@ -2250,16 +2264,276 @@ 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;
+
+        ClassNode elementType = wrapTypeIfNecessary(elementTypes[0].getType());
+        return typeCheckMethodArgumentWithGenerics(expected.getType(), 
elementType, false)
+                && isSubtypeWithoutConversion(elementTypes[0].getType(), 
expected.getType())
+                && !hasIncompatibleGenerics(expected.getType(), elementType);
+    }
+
+    /**
+     * Whether a value of {@code type} is a {@code target} as it is. A value 
given a type argument
+     * from the target is stored as it is, so it is not converted as an 
assigned value may be, such
+     * as an {@code int} to a {@code Long} or a {@code GString} to a {@code 
String}.
+     */
+    private static boolean isSubtypeWithoutConversion(final ClassNode type, 
final ClassNode target) {
+        if (type.isArray() && target.isArray()) { // Integer[] is a Number[], 
but not a Long[]; int[] is only an int[]
+            ClassNode typeComponent = type.getComponentType(), targetComponent 
= target.getComponentType();
+            if (isPrimitiveType(typeComponent) || 
isPrimitiveType(targetComponent)) return typeComponent.equals(targetComponent);
+            return isSubtypeWithoutConversion(typeComponent, targetComponent);
+        }
+        if (type.isArray() || target.isArray() || 
target.isGenericsPlaceHolder()) return true; // checked elsewhere
+        return implementsInterfaceOrIsSubclassOf(wrapTypeIfNecessary(type), 
wrapTypeIfNecessary(target));
+    }
+
+    /**
+     * 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;
+            }
+        }
+        // a wildcard taken as its bound must still fit the target where the 
type parameter is
+        // nested in an invariant type argument, as T is in List<List<T>>
+        ClassNode instantiated = applyGenericsContext(connections, viewed);
+        if (!GenericsUtils.hasUnresolvedGenerics(instantiated) && 
hasIncompatibleGenerics(targetType, instantiated)) 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;
+                ClassNode[] samParameterTypes = null;
+                List<FunctorSignature> fitting = null;
+                if (CLOSURE_TYPE.equals(parameterType)) {
+                    GenericsType[] gts = parameterType.getGenericsTypes();
+                    if (gts != null && gts.length == 1) expected = 
getCombinedBoundType(gts[0]);
+                } else if (isSAMType(parameterType)) {
+                    Tuple2<ClassNode[], ClassNode> sam = 
GenericsUtils.parameterizeSAM(parameterType);
+                    expected = sam.getV2();
+                    samParameterTypes = sam.getV1();
+                    // the target gives the parameters of the SAM, so a 
closure, lambda or
+                    // method reference must accept them
+                    if (argument instanceof ClosureExpression closure && 
!acceptsParameters(closure, samParameterTypes)) return false;
+                    if (argument instanceof MethodPointerExpression pointer) {
+                        fitting = fittingSignatures(pointer, 
samParameterTypes);

Review Comment:
   This is the acceptance that lets `Function<String, List<String>> f = 
toFn(Arrays::asList)` through, which matches `javac` and the direct assignment 
`Arrays::asList`. Under `@CompileStatic` the `toFn` form then fails at run time 
(`String` cannot be cast to `Object[]`); `@TypeChecked` and the direct 
assignment both run. I wonder whether the statically compiled call through the 
generic identity still treats the argument as a `T[]` rather than as a varargs 
element.





> STC: an upper-bounded wildcard argument is checked against a type parameter's 
> bound the wrong way round
> -------------------------------------------------------------------------------------------------------
>
>                 Key: GROOVY-12754
>                 URL: https://issues.apache.org/jira/browse/GROOVY-12754
>             Project: Groovy
>          Issue Type: Bug
>          Components: Static Type Checker
>    Affects Versions: 6.0.0
>            Reporter: Scott Murphy Heiberg
>            Priority: Major
>
> Static type checking rejects a call that passes an upper-bounded wildcard, 
> such as {{List<? extends Integer>}}, to a generic method whose type parameter 
> is bounded by a supertype of the wildcard's bound. It accepts the call when 
> the wildcard's bound is wider than the type parameter's. javac does the 
> opposite in both cases.
> {code:groovy}
> @groovy.transform.CompileStatic
> class C {
>     static <T extends Number> T first(List<T> list) { list.get(0) }
>     static <T extends CharSequence> int len(Class<T> type) { 0 }
>     static <T extends Integer> T narrow(List<T> list) { list.get(0) }
>     static Object a(List<? extends Integer> ints) { first(ints) }  // 
> rejected, javac accepts
>     static int b(Class<? extends String> type) { len(type) }       // 
> rejected, javac accepts
>     static Object c(List<? extends Number> nums) { narrow(nums) }  // 
> accepted, javac rejects
> }
> {code}
> {noformat}
> [Static type checking] - Cannot call <T extends java.lang.Number> 
> C#first(java.util.List<T>) with arguments [java.util.List<? extends 
> java.lang.Integer>]
> [Static type checking] - Cannot call <T extends java.lang.CharSequence> 
> C#len(java.lang.Class<T>) with arguments [java.lang.Class<? extends 
> java.lang.String>]
> {noformat}
> The capture of {{? extends B}} is a subtype of {{B}} (JLS 5.1.10), so it is 
> within the bound of {{T}} exactly when {{B}} is. javac reports "inference 
> variable T has incompatible bounds" for {{c}}. Groovy compiles {{c}}, and 
> {{c([1.5d])}} returns {{1}}.
> {{StaticTypeCheckingSupport#compatibleConnection}} tests a wildcard witness 
> with {{connection.isCompatibleWith(bound)}}, which asks whether the type 
> parameter's bound fits within {{? extends B}}. For a type argument {{B}}, it 
> tests {{? super B}} against the bound. An upper-bounded wildcard should take 
> the same test.
> PR: https://github.com/apache/groovy/pull/3285



--
This message was sent by Atlassian Jira
(v10.3.26#10030026)

Reply via email to