Examples with DIRECT_METHOD_CALL_TARGET org.codehaus.groovy.transform.stc.StaticTypesMarker.DIRECT_METHOD_CALL_TARGET used on opensource projects

Example 1 with DIRECT_METHOD_CALL_TARGET

use of org.codehaus.groovy.transform.stc.StaticTypesMarker.DIRECT_METHOD_CALL_TARGET in project groovy by apache.

the class StaticTypeCheckingVisitor method ensureValidSetter.

/**
 * Given a binary expression corresponding to an assignment, will check that
 * the type of the RHS matches one of the possible setters and if not, throw
 * a type checking error.
 *
 * @param expression      the assignment expression
 * @param leftExpression  left expression of the assignment
 * @param rightExpression right expression of the assignment
 * @param setterInfo      possible setters
 * @return {@code false} if valid setter found or {@code true} if type checking error created
 */
private boolean ensureValidSetter(final Expression expression, final Expression leftExpression, final Expression rightExpression, final SetterInfo setterInfo) {
    // for expressions like foo = { ... }
    // we know that the RHS type is a closure
    // but we must check if the binary expression is an assignment
    // because we need to check if a setter uses @DelegatesTo
    VariableExpression receiver = varX("%", setterInfo.receiverType);
    // for "x op= y" expression, find type as if it was "x = x op y"
    Expression valueExpression = rightExpression;
    if (isCompoundAssignment(expression)) {
        Token op = ((BinaryExpression) expression).getOperation();
        if (op.getType() == ELVIS_EQUAL) {
            // GROOVY-10419: "x ?= y"
            valueExpression = elvisX(leftExpression, rightExpression);
        } else {
            op = Token.newSymbol(TokenUtil.removeAssignment(op.getType()), op.getStartLine(), op.getStartColumn());
            valueExpression = binX(leftExpression, op, rightExpression);
        }
    }
    Function<Expression, MethodNode> setterCall = right -> {
        MethodCallExpression call = callX(receiver, setterInfo.name, right);
        call.setImplicitThis(false);
        visitMethodCallExpression(call);
        return call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
    };
    Function<MethodNode, ClassNode> setterType = setter -> {
        ClassNode type = setter.getParameters()[0].getOriginType();
        if (!setter.isStatic() && !(setter instanceof ExtensionMethodNode) && GenericsUtils.hasUnresolvedGenerics(type)) {
            type = applyGenericsContext(extractPlaceHolders(setterInfo.receiverType, setter.getDeclaringClass()), type);
        }
        return type;
    };
    MethodNode methodTarget = setterCall.apply(valueExpression);
    if (methodTarget == null && !isCompoundAssignment(expression)) {
        // if no direct match, try implicit conversion
        for (MethodNode setter : setterInfo.setters) {
            ClassNode lType = setterType.apply(setter);
            ClassNode rType = getDeclaredOrInferredType(valueExpression);
            if (checkCompatibleAssignmentTypes(lType, rType, valueExpression, false)) {
                methodTarget = setterCall.apply(castX(lType, valueExpression));
                if (methodTarget != null) {
                    break;
                }
            }
        }
    }
    if (methodTarget != null) {
        for (MethodNode setter : setterInfo.setters) {
            if (setter == methodTarget) {
                leftExpression.putNodeMetaData(DIRECT_METHOD_CALL_TARGET, methodTarget);
                // clear assumption
                leftExpression.removeNodeMetaData(INFERRED_TYPE);
                storeType(leftExpression, setterType.apply(methodTarget));
                break;
            }
        }
        return false;
    } else {
        ClassNode firstSetterType = setterType.apply(setterInfo.setters.get(0));
        addAssignmentError(firstSetterType, getType(valueExpression), expression);
        return true;
    }
}

Example 2 with DIRECT_METHOD_CALL_TARGET

use of org.codehaus.groovy.transform.stc.StaticTypesMarker.DIRECT_METHOD_CALL_TARGET in project groovy by apache.

the class StaticTypeCheckingVisitor method resolvePlaceholdersFromImplicitTypeHints.

/**
 * Given method call like "m(Collections.emptyList())", the type of the call
 * argument is {@code List<T>} without explicit type arguments. Knowning the
 * method target of "m", {@code T} could be resolved.
 */
private void resolvePlaceholdersFromImplicitTypeHints(final ClassNode[] actuals, final ArgumentListExpression argumentList, final Parameter[] parameterArray) {
    int np = parameterArray.length;
    for (int i = 0, n = actuals.length; np > 0 && i < n; i += 1) {
        Expression a = argumentList.getExpression(i);
        Parameter p = parameterArray[Math.min(i, np - 1)];
        ClassNode at = actuals[i], pt = p.getOriginType();
        if (!isUsingGenericsOrIsArrayUsingGenerics(pt))
            continue;
        if (i >= (np - 1) && pt.isArray() && !at.isArray())
            pt = pt.getComponentType();
        if (a instanceof ListExpression) {
            actuals[i] = getLiteralResultType(pt, at, ArrayList_TYPE);
        } else if (a instanceof MapExpression) {
            actuals[i] = getLiteralResultType(pt, at, LinkedHashMap_TYPE);
        } else if (a instanceof ConstructorCallExpression) {
            // GROOVY-10086
            inferDiamondType((ConstructorCallExpression) a, pt);
        } else if (a instanceof TernaryExpression && at.getGenericsTypes() != null && at.getGenericsTypes().length == 0) {
            // GROOVY-9983: double diamond scenario -- "m(flag ? new Type<>(...) : new Type<>(...))"
            typeCheckingContext.pushEnclosingBinaryExpression(assignX(varX(p), a, a));
            // re-visit with target type witness
            a.visit(this);
            typeCheckingContext.popEnclosingBinaryExpression();
            actuals[i] = getType(a);
        }
        // check for method call with known target
        if (!(a instanceof MethodCallExpression))
            continue;
        if (((MethodCallExpression) a).isUsingGenerics())
            continue;
        MethodNode aNode = a.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
        if (aNode == null || aNode.getGenericsTypes() == null)
            continue;
        // and unknown generics
        if (!GenericsUtils.hasUnresolvedGenerics(at))
            continue;
        while (!at.equals(pt) && !isObjectType(at) && !isGenericsPlaceHolderOrArrayOf(at)) {
            at = applyGenericsContext(GenericsUtils.extractPlaceholders(at), getNextSuperClass(at, pt));
        }
        // try to resolve placeholder(s) in argument type using parameter type
        Map<GenericsTypeName, GenericsType> linked = new HashMap<>();
        Map<GenericsTypeName, GenericsType> source = GenericsUtils.extractPlaceholders(at);
        Map<GenericsTypeName, GenericsType> target = GenericsUtils.extractPlaceholders(pt);
        // connect E:T from source to E:Type from target
        for (GenericsType placeholder : aNode.getGenericsTypes()) {
            for (Map.Entry<GenericsTypeName, GenericsType> e : source.entrySet()) {
                if (e.getValue().getNodeMetaData(GenericsType.class) == placeholder) {
                    Optional.ofNullable(target.get(e.getKey())).filter(gt -> isAssignableTo(gt.getType(), placeholder.getType())).ifPresent(gt -> linked.put(new GenericsTypeName(e.getValue().getName()), gt));
                    break;
                }
            }
        }
        actuals[i] = applyGenericsContext(linked, at);
    }
}