#4173

Committed 14 Nov 2024 06:18PM UTC coverage: 61.202% (+0.001%) from 61.201%

Build # #4173

Build Type

push

github

Committed by

adangel

Commit Message

[java] Propagate unknown type better when mref is unresolved (#5330)

Merge pull request #5330 from oowekyala:typeres-fix-inference-issue-mref

Run Details

17441 of 28029 branches covered (62.22%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

39241 of 64586 relevant lines covered (60.76%)

0.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.59

/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/types/internal/infer/ExprOps.java

/*
 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
 */

package net.sourceforge.pmd.lang.java.types.internal.infer;

import static net.sourceforge.pmd.lang.java.types.TypeConversion.capture;
import static net.sourceforge.pmd.lang.java.types.internal.InternalMethodTypeItf.cast;
import static net.sourceforge.pmd.util.CollectionUtil.listOf;

import java.lang.reflect.Modifier;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

import net.sourceforge.pmd.lang.java.ast.JavaNode;
import net.sourceforge.pmd.lang.java.symbols.JClassSymbol;
import net.sourceforge.pmd.lang.java.symbols.JMethodSymbol;
import net.sourceforge.pmd.lang.java.symbols.JTypeDeclSymbol;
import net.sourceforge.pmd.lang.java.types.JClassType;
import net.sourceforge.pmd.lang.java.types.JMethodSig;
import net.sourceforge.pmd.lang.java.types.JTypeMirror;
import net.sourceforge.pmd.lang.java.types.JTypeVar;
import net.sourceforge.pmd.lang.java.types.Substitution;
import net.sourceforge.pmd.lang.java.types.TypeOps;
import net.sourceforge.pmd.lang.java.types.TypeSystem;
import net.sourceforge.pmd.lang.java.types.TypingContext;
import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.BranchingMirror;
import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.FunctionalExprMirror;
import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.InvocationMirror;
import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.InvocationMirror.MethodCtDecl;
import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.LambdaExprMirror;
import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.MethodRefMirror;
import net.sourceforge.pmd.util.CollectionUtil;

@SuppressWarnings("PMD.CompareObjectsWithEquals")
final class ExprOps {

    private final Infer infer;
    private final TypeSystem ts;

    ExprOps(Infer infer) {
        this.infer = infer;
        this.ts = infer.getTypeSystem();
        assert ts != null;
    }

    /**
     * Returns true if the argument expression is potentially
     * compatible with type t, as specified by JLS§15.12.2.1:
     *
     * https://docs.oracle.com/javase/specs/jls/se9/html/jls-15.html#jls-15.12.1
     *
     * @param m Method for which the potential applicability is being tested
     * @param e Argument expression
     * @param t Formal parameter type
     */
    boolean isPotentiallyCompatible(JMethodSig m, ExprMirror e, JTypeMirror t) {
        if (e instanceof BranchingMirror) {
            // A conditional expression (§15.25) is potentially compatible with a type if each
            // of its second and third operand expressions are potentially compatible with that type.

            BranchingMirror cond = (BranchingMirror) e;
            return cond.branchesMatch(branch -> isPotentiallyCompatible(m, branch, t));

        }

        boolean isLambdaOrRef = e instanceof FunctionalExprMirror;

        if (isLambdaOrRef) {
            if (t instanceof JTypeVar) {
                //  A lambda expression or a method reference expression is potentially compatible with
                //  a type variable if the type variable is a type parameter of the candidate method.
                return m.getTypeParameters().contains(t);
            }
            JMethodSig fun = TypeOps.findFunctionalInterfaceMethod(t);
            if (fun == null) {
                // t is not a functional interface
                return false;
            }

            if (e instanceof LambdaExprMirror) {
                LambdaExprMirror lambda = (LambdaExprMirror) e;
                if (fun.getArity() != lambda.getParamCount()) {
                    return false;
                }

                boolean expectsVoid = fun.getReturnType() == ts.NO_TYPE;

                return expectsVoid && lambda.isVoidCompatible() || lambda.isValueCompatible();

            } else {
                // is method reference

                // TODO need to look for potentially applicable methods
                return true;
            }
        }

        // A class instance creation expression, a method invocation expression, or an expression of
        // a standalone form (§15.2) is potentially compatible with any type.
        // (ie anything else)
        return true;
    }

    /**
     * Returns true if the the argument expression is pertinent
     * to applicability for the potentially applicable method m,
     * called at site 'invoc', as specified by JLS§15.12.2.2:
     *
     * https://docs.oracle.com/javase/specs/jls/se9/html/jls-15.html#jls-15.12.2.2
     *
     * @param arg        Argument expression
     * @param m          Method type
     * @param formalType Type of the formal parameter
     * @param invoc      Invocation expression
     */
    static boolean isPertinentToApplicability(ExprMirror arg, JMethodSig m, JTypeMirror formalType, InvocationMirror invoc) {
        // An argument expression is considered pertinent to applicability
        // for a potentially applicable method m unless it has one of the following forms:

        if (arg instanceof LambdaExprMirror) {
            LambdaExprMirror lambda = (LambdaExprMirror) arg;

            // An implicitly typed lambda expression(§ 15.27 .1).
            if (!lambda.isExplicitlyTyped()) {
                return false;
            }

            // An explicitly typed lambda expression where at least
            // one result expression is not pertinent to applicability.
            for (ExprMirror it : lambda.getResultExpressions()) {
                if (!isPertinentToApplicability(it, m, formalType, invoc)) {
                    return false;
                }
            }

            //  If m is a generic method and the method invocation does
            //  not provide explicit type arguments, an explicitly typed
            //  lambda expression for which the corresponding target type
            //  (as derived from the signature of m) is a type parameter of m.
            return !m.isGeneric()
                    || !invoc.getExplicitTypeArguments().isEmpty()
                    || !formalType.isTypeVariable();
        }

        if (arg instanceof MethodRefMirror) {
            // An inexact method reference expression(§ 15.13 .1).
            return getExactMethod((MethodRefMirror) arg) != null
                    //  If m is a generic method and the method invocation does
                    //  not provide explicit type arguments, an exact method
                    //  reference expression for which the corresponding target type
                    //  (as derived from the signature of m) is a type parameter of m.
                    && (!m.isGeneric()
                        || !invoc.getExplicitTypeArguments().isEmpty()
                        || !formalType.isTypeVariable());
        }

        if (arg instanceof BranchingMirror) {
            // A conditional expression (§15.25) is potentially compatible with a type if each
            // of its second and third operand expressions are potentially compatible with that type.

            BranchingMirror cond = (BranchingMirror) arg;
            return cond.branchesMatch(branch -> isPertinentToApplicability(branch, m, formalType, invoc));
        }

        return true;
    }


    /**
     * Returns null if the method reference is inexact.
     */
    static @Nullable JMethodSig getExactMethod(MethodRefMirror mref) {
        JMethodSig cached = mref.getCachedExactMethod();

        if (cached == null) { // inexact
            return null;
        }

        if (cached.getTypeSystem().UNRESOLVED_METHOD == cached) {
            cached = computeExactMethod(mref);
            mref.setCachedExactMethod(cached); // set to null if inexact, sentinel is UNRESOLVED_METHOD
        }

        return cached;
    }

    private static @Nullable JMethodSig computeExactMethod(MethodRefMirror mref) {


        final @Nullable JTypeMirror lhs = mref.getLhsIfType();

        List<JMethodSig> accessible;

        if (mref.isConstructorRef()) {
            if (lhs == null) {
                // ct error, already reported as a missing symbol in our system
                return null;
            } else if (lhs.isArray()) {
                // A method reference expression of the form ArrayType :: new is always exact.
                // But:  If a method reference expression has the form ArrayType :: new, then ArrayType
                // must denote a type that is reifiable (§4.7), or a compile-time error occurs.
                if (lhs.isReifiable()) {
                    JTypeDeclSymbol symbol = lhs.getSymbol();

                    assert symbol instanceof JClassSymbol && ((JClassSymbol) symbol).isArray()
                        : "Reifiable array should present a symbol! " + lhs;

                    return lhs.getConstructors().get(0);
                } else {
                    // todo compile time error
                    return null;
                }
            } else {
                if (lhs.isRaw() || !(lhs instanceof JClassType)) {
                    return null;
                }

                accessible = TypeOps.filterAccessible(lhs.getConstructors(),
                                                      mref.getEnclosingType().getSymbol());
            }
        } else {
            JClassType enclosing = mref.getEnclosingType();
            accessible = mref.getTypeToSearch()
                             .streamMethods(TypeOps.accessibleMethodFilter(mref.getMethodName(), enclosing.getSymbol()))
                             .collect(OverloadSet.collectMostSpecific(enclosing));
        }

        if (accessible.size() == 1) {
            JMethodSig candidate = accessible.get(0);
            if (candidate.isVarargs()
                || candidate.isGeneric() && mref.getExplicitTypeArguments().isEmpty()) {
                return null;
            }

            candidate = candidate.subst(Substitution.mapping(candidate.getTypeParameters(), mref.getExplicitTypeArguments()));

            if (lhs != null && lhs.isRaw()) {
                // can be raw if the method doesn't mention type vars
                // of the original owner, ie the erased method is the
                // same as the generic method.
                JClassType lhsClass = (JClassType) candidate.getDeclaringType();
                JMethodSig unerased = cast(cast(candidate).withOwner(lhsClass.getGenericTypeDeclaration())).originalMethod();
                if (TypeOps.mentionsAny(unerased, lhsClass.getFormalTypeParams())) {
                    return null;
                }
            }

            // For exact method references, the return type is Class<? extends T> (no erasure).
            // So it's mref::getTypeToSearch and not mref.getTypeToSearch()::getErasure
            return adaptGetClass(candidate, mref::getTypeToSearch);
        } else {
            return null;
        }
    }


    // for inexact method refs
    @Nullable MethodCtDecl findInexactMethodRefCompileTimeDecl(MethodRefMirror mref, JMethodSig targetType) {
        // https://docs.oracle.com/javase/specs/jls/se14/html/jls-15.html#jls-15.13.1

        JTypeMirror lhsIfType = mref.getLhsIfType();
        boolean acceptLowerArity = lhsIfType != null && lhsIfType.isClassOrInterface() && !mref.isConstructorRef();

        MethodCallSite site1 = infer.newCallSite(methodRefAsInvocation(mref, targetType, false), null);
        site1.setLogging(!acceptLowerArity); // if we do only one search, then failure matters
        MethodCtDecl ctd1 = infer.determineInvocationTypeOrFail(site1);
        JMethodSig m1 = ctd1.getMethodType();

        if (acceptLowerArity) {
            // then we need to perform two searches, one with arity n, looking for static methods,
            // one with n-1, looking for instance methods

            MethodCallSite site2 = infer.newCallSite(methodRefAsInvocation(mref, targetType, true), null);
            site2.setLogging(false);
            MethodCtDecl ctd2 = infer.determineInvocationTypeOrFail(site2);
            JMethodSig m2 = ctd2.getMethodType();

            //  If the first search produces a most specific method that is static,
            //  and the set of applicable methods produced by the second search
            //  contains no non-static methods, then the compile-time declaration
            //  is the most specific method of the first search.
            if (m1 != ts.UNRESOLVED_METHOD && m1.isStatic() && (m2 == ts.UNRESOLVED_METHOD || m2.isStatic())) {
                return ctd1;
            } else if (m2 != ts.UNRESOLVED_METHOD && !m2.isStatic() && (m1 == ts.UNRESOLVED_METHOD || !m1.isStatic())) {
                // Otherwise, if the set of applicable methods produced by the
                // first search contains no static methods, and the second search
                // produces a most specific method that is non-static, then the
                // compile-time declaration is the most specific method of the second search.
                return ctd2;
            }

            //  Otherwise, there is no compile-time declaration.
            return null;
        } else if (m1 == ts.UNRESOLVED_METHOD || m1.isStatic()) {
            // if the most specific applicable method is static, there is no compile-time declaration.
            return null;
        } else {
            // Otherwise, the compile-time declaration is the most specific applicable method.
            return ctd1;
        }
    }

    static InvocationMirror methodRefAsInvocation(final MethodRefMirror mref, JMethodSig targetType, boolean asInstanceMethod) {
        // the arguments are treated as if they were of the type
        // of the formal parameters of the candidate
        List<JTypeMirror> formals = targetType.getFormalParameters();
        if (asInstanceMethod && !formals.isEmpty()) {
            formals = formals.subList(1, formals.size()); // skip first param (receiver)
        }

        List<ExprMirror> arguments = CollectionUtil.map(
            formals,
            fi -> new ExprMirror() {

                @Override
                public void setInferredType(JTypeMirror mirror) {
                    // do nothing
                }

                @Override
                public @Nullable JTypeMirror getInferredType() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public JavaNode getLocation() {
                    return mref.getLocation();
                }

                @Override
                public JTypeMirror getStandaloneType() {
                    return fi;
                }

                @Override
                public String toString() {
                    return "formal : " + fi;
                }

                @Override
                public TypingContext getTypingContext() {
                    return mref.getTypingContext();
                }

                @Override
                public boolean isEquivalentToUnderlyingAst() {
                    throw new UnsupportedOperationException("Cannot invoque isSemanticallyEquivalent on this mirror, it doesn't have a backing AST node: " + this);
                }
            }
        );


        return new InvocationMirror() {

            private MethodCtDecl mt;

            @Override
            public JavaNode getLocation() {
                return mref.getLocation();
            }

            @Override
            public Iterable<JMethodSig> getAccessibleCandidates() {
                return ExprOps.getAccessibleCandidates(mref, asInstanceMethod, targetType);
            }

            @Override
            public JTypeMirror getErasedReceiverType() {
                return mref.getTypeToSearch().getErasure();
            }

            @Override
            public @Nullable JTypeMirror getReceiverType() {
                return mref.getTypeToSearch();
            }

            @Override
            public List<JTypeMirror> getExplicitTypeArguments() {
                return mref.getExplicitTypeArguments();
            }

            @Override
            public JavaNode getExplicitTargLoc(int i) {
                throw new IndexOutOfBoundsException();
            }

            @Override
            public String getName() {
                return mref.getMethodName();
            }

            @Override
            public List<ExprMirror> getArgumentExpressions() {
                return arguments;
            }

            @Override
            public int getArgumentCount() {
                return arguments.size();
            }

            @Override
            public void setCtDecl(MethodCtDecl methodType) {
                this.mt = methodType;
            }

            @Override
            public @Nullable MethodCtDecl getCtDecl() {
                return mt;
            }

            JTypeMirror inferred;

            @Override
            public void setInferredType(JTypeMirror mirror) {
                // todo is this useful for method refs?
                inferred = mirror;
            }

            @Override
            public JTypeMirror getInferredType() {
                return inferred;
            }

            @Override
            public @NonNull JClassType getEnclosingType() {
                return mref.getEnclosingType();
            }

            @Override
            public String toString() {
                return "Method ref adapter (for " + mref + ")";
            }

            @Override
            public TypingContext getTypingContext() {
                return mref.getTypingContext();
            }

            @Override
            public boolean isEquivalentToUnderlyingAst() {
                throw new UnsupportedOperationException("Cannot invoque isSemanticallyEquivalent on this mirror, it doesn't have a backing AST node: " + this);
            }
        };
    }

    private static Iterable<JMethodSig> getAccessibleCandidates(MethodRefMirror mref, boolean asInstanceMethod, JMethodSig targetType) {
        JMethodSig exactMethod = getExactMethod(mref);
        if (exactMethod != null) {
            return Collections.singletonList(exactMethod);
        } else {
            final JTypeMirror actualTypeToSearch;
            {
                JTypeMirror typeToSearch = mref.getTypeToSearch();
                if (typeToSearch.isArray() && mref.isConstructorRef()) {
                    // ArrayType :: new
                    return typeToSearch.getConstructors();
                } else if (typeToSearch instanceof JClassType && mref.isConstructorRef()) {
                    // ClassType :: [TypeArguments] new
                    // TODO treatment of raw constructors is whacky
                    return TypeOps.lazyFilterAccessible(typeToSearch.getConstructors(), mref.getEnclosingType().getSymbol());
                }

                if (asInstanceMethod && typeToSearch.isRaw() && typeToSearch instanceof JClassType
                    && targetType.getArity() > 0) {
                    //  In the second search, if P1, ..., Pn is not empty
                    //  and P1 is a subtype of ReferenceType, then the
                    //  method reference expression is treated as if it were
                    //  a method invocation expression with argument expressions
                    //  of types P2, ..., Pn. If ReferenceType is a raw type,
                    //  and there exists a parameterization of this type, G<...>,
                    //  that is a supertype of P1, the type to search is the result
                    //  of capture conversion (§5.1.10) applied to G<...>; otherwise,
                    //  the type to search is the same as the type of the first search.

                    JClassType type = (JClassType) typeToSearch;
                    JTypeMirror p1 = targetType.getFormalParameters().get(0);
                    JTypeMirror asSuper = p1.getAsSuper(type.getSymbol());
                    if (asSuper != null && asSuper.isParameterizedType()) {
                        typeToSearch = capture(asSuper);
                    }
                }
                actualTypeToSearch = typeToSearch;
            }

            // Primary :: [TypeArguments] Identifier
            // ExpressionName :: [TypeArguments] Identifier
            // super :: [TypeArguments] Identifier
            // TypeName.super :: [TypeArguments] Identifier
            // ReferenceType :: [TypeArguments] Identifier

            boolean acceptsInstanceMethods = canUseInstanceMethods(actualTypeToSearch, targetType, mref);

            Predicate<JMethodSymbol> prefilter = TypeOps.accessibleMethodFilter(mref.getMethodName(), mref.getEnclosingType().getSymbol())
                                                        .and(m -> Modifier.isStatic(m.getModifiers())
                                                            || acceptsInstanceMethods);
            return actualTypeToSearch.streamMethods(prefilter).collect(Collectors.toList());
        }
    }

    private static boolean canUseInstanceMethods(JTypeMirror typeToSearch, JMethodSig sig, MethodRefMirror mref) {
        // For example, if you write
        // stringStream.map(Objects::toString),

        // The type to search is Objects. But Objects inherits Object.toString(),
        // which could not be called on a string (String.toString() != Objects.toString()).

        if (mref.getLhsIfType() != null && !sig.getFormalParameters().isEmpty()) {
            // ReferenceType :: [TypeArguments] Identifier
            JTypeMirror firstFormal = sig.getFormalParameters().get(0);
            return firstFormal.isSubtypeOf(typeToSearch);
        }
        return true;
    }


    /**
     * Calls to {@link Object#getClass()} on a type {@code T} have type
     * {@code Class<? extends |T|>}. If the selected method is that method, then
     * we need to replace its return type (the symbol has return type {@link Object}).
     *
     * <p>For exact method reference expressions, the type is {@code <? extends T>} (no erasure).
     *
     * @param sig                   Selected signature
     * @param replacementReturnType Lazily created, because in many cases it's not necessary
     *
     * @return Signature, adapted if it is {@link Object#getClass()}
     */
    static JMethodSig adaptGetClass(JMethodSig sig, Supplier<JTypeMirror> replacementReturnType) {
        TypeSystem ts = sig.getTypeSystem();
        if ("getClass".equals(sig.getName()) && sig.getDeclaringType().equals(ts.OBJECT)) {
            return cast(cast(sig).withReturnType(getClassReturn(replacementReturnType.get(), ts))).markAsAdapted();
        }
        return sig;
    }

    private static JTypeMirror getClassReturn(JTypeMirror erasedReceiverType, TypeSystem ts) {
        return ts.parameterise(ts.getClassSymbol(Class.class), listOf(ts.wildcard(true, erasedReceiverType)));
    }

    static boolean isContextDependent(JMethodSig m) {
        m = cast(m).adaptedMethod();
        return m.isGeneric() && TypeOps.mentionsAny(m.getReturnType(), m.getTypeParameters());
    }
}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.lang.java.types.internal.infer;
6
7	import static net.sourceforge.pmd.lang.java.types.TypeConversion.capture;
8	import static net.sourceforge.pmd.lang.java.types.internal.InternalMethodTypeItf.cast;
9	import static net.sourceforge.pmd.util.CollectionUtil.listOf;
10
11	import java.lang.reflect.Modifier;
12	import java.util.Collections;
13	import java.util.List;
14	import java.util.function.Predicate;
15	import java.util.function.Supplier;
16	import java.util.stream.Collectors;
17
18	import org.checkerframework.checker.nullness.qual.NonNull;
19	import org.checkerframework.checker.nullness.qual.Nullable;
20
21	import net.sourceforge.pmd.lang.java.ast.JavaNode;
22	import net.sourceforge.pmd.lang.java.symbols.JClassSymbol;
23	import net.sourceforge.pmd.lang.java.symbols.JMethodSymbol;
24	import net.sourceforge.pmd.lang.java.symbols.JTypeDeclSymbol;
25	import net.sourceforge.pmd.lang.java.types.JClassType;
26	import net.sourceforge.pmd.lang.java.types.JMethodSig;
27	import net.sourceforge.pmd.lang.java.types.JTypeMirror;
28	import net.sourceforge.pmd.lang.java.types.JTypeVar;
29	import net.sourceforge.pmd.lang.java.types.Substitution;
30	import net.sourceforge.pmd.lang.java.types.TypeOps;
31	import net.sourceforge.pmd.lang.java.types.TypeSystem;
32	import net.sourceforge.pmd.lang.java.types.TypingContext;
33	import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.BranchingMirror;
34	import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.FunctionalExprMirror;
35	import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.InvocationMirror;
36	import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.InvocationMirror.MethodCtDecl;
37	import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.LambdaExprMirror;
38	import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.MethodRefMirror;
39	import net.sourceforge.pmd.util.CollectionUtil;
40
41	@SuppressWarnings("PMD.CompareObjectsWithEquals")	1✔
42	final class ExprOps {
43
44	private final Infer infer;
45	private final TypeSystem ts;
46
47	ExprOps(Infer infer) {	1✔
48	this.infer = infer;	1✔
49	this.ts = infer.getTypeSystem();	1✔
50	assert ts != null;	1!
51	}	1✔
52
53	/**
54	* Returns true if the argument expression is potentially
55	* compatible with type t, as specified by JLS§15.12.2.1:
56	*
57	* https://docs.oracle.com/javase/specs/jls/se9/html/jls-15.html#jls-15.12.1
58	*
59	* @param m Method for which the potential applicability is being tested
60	* @param e Argument expression
61	* @param t Formal parameter type
62	*/
63	boolean isPotentiallyCompatible(JMethodSig m, ExprMirror e, JTypeMirror t) {
64	if (e instanceof BranchingMirror) {	1✔
65	// A conditional expression (§15.25) is potentially compatible with a type if each
66	// of its second and third operand expressions are potentially compatible with that type.
67
68	BranchingMirror cond = (BranchingMirror) e;	1✔
69	return cond.branchesMatch(branch -> isPotentiallyCompatible(m, branch, t));	1✔
70
71	}
72
73	boolean isLambdaOrRef = e instanceof FunctionalExprMirror;	1✔
74
75	if (isLambdaOrRef) {	1✔
76	if (t instanceof JTypeVar) {	1✔
77	// A lambda expression or a method reference expression is potentially compatible with
78	// a type variable if the type variable is a type parameter of the candidate method.
79	return m.getTypeParameters().contains(t);	1✔
80	}
81	JMethodSig fun = TypeOps.findFunctionalInterfaceMethod(t);	1✔
82	if (fun == null) {	1✔
83	// t is not a functional interface
84	return false;	1✔
85	}
86
87	if (e instanceof LambdaExprMirror) {	1✔
88	LambdaExprMirror lambda = (LambdaExprMirror) e;	1✔
89	if (fun.getArity() != lambda.getParamCount()) {	1✔
90	return false;	1✔
91	}
92
93	boolean expectsVoid = fun.getReturnType() == ts.NO_TYPE;	1✔
94
95	return expectsVoid && lambda.isVoidCompatible() \|\| lambda.isValueCompatible();	1!
96
97	} else {
98	// is method reference
99
100	// TODO need to look for potentially applicable methods
101	return true;	1✔
102	}
103	}
104
105	// A class instance creation expression, a method invocation expression, or an expression of
106	// a standalone form (§15.2) is potentially compatible with any type.
107	// (ie anything else)
108	return true;	1✔
109	}
110
111	/**
112	* Returns true if the the argument expression is pertinent
113	* to applicability for the potentially applicable method m,
114	* called at site 'invoc', as specified by JLS§15.12.2.2:
115	*
116	* https://docs.oracle.com/javase/specs/jls/se9/html/jls-15.html#jls-15.12.2.2
117	*
118	* @param arg Argument expression
119	* @param m Method type
120	* @param formalType Type of the formal parameter
121	* @param invoc Invocation expression
122	*/
123	static boolean isPertinentToApplicability(ExprMirror arg, JMethodSig m, JTypeMirror formalType, InvocationMirror invoc) {
124	// An argument expression is considered pertinent to applicability
125	// for a potentially applicable method m unless it has one of the following forms:
126
127	if (arg instanceof LambdaExprMirror) {	1✔
128	LambdaExprMirror lambda = (LambdaExprMirror) arg;	1✔
129
130	// An implicitly typed lambda expression(§ 15.27 .1).
131	if (!lambda.isExplicitlyTyped()) {	1✔
132	return false;	1✔
133	}
134
135	// An explicitly typed lambda expression where at least
136	// one result expression is not pertinent to applicability.
137	for (ExprMirror it : lambda.getResultExpressions()) {	1✔
138	if (!isPertinentToApplicability(it, m, formalType, invoc)) {	1!
139	return false;	×
140	}
141	}	1✔
142
143	// If m is a generic method and the method invocation does
144	// not provide explicit type arguments, an explicitly typed
145	// lambda expression for which the corresponding target type
146	// (as derived from the signature of m) is a type parameter of m.
147	return !m.isGeneric()	1✔
148	\|\| !invoc.getExplicitTypeArguments().isEmpty()	1!
149	\|\| !formalType.isTypeVariable();	1!
150	}
151
152	if (arg instanceof MethodRefMirror) {	1✔
153	// An inexact method reference expression(§ 15.13 .1).
154	return getExactMethod((MethodRefMirror) arg) != null	1✔
155	// If m is a generic method and the method invocation does
156	// not provide explicit type arguments, an exact method
157	// reference expression for which the corresponding target type
158	// (as derived from the signature of m) is a type parameter of m.
159	&& (!m.isGeneric()	1✔
160	\|\| !invoc.getExplicitTypeArguments().isEmpty()	1✔
161	\|\| !formalType.isTypeVariable());	1✔
162	}
163
164	if (arg instanceof BranchingMirror) {	1✔
165	// A conditional expression (§15.25) is potentially compatible with a type if each
166	// of its second and third operand expressions are potentially compatible with that type.
167
168	BranchingMirror cond = (BranchingMirror) arg;	1✔
169	return cond.branchesMatch(branch -> isPertinentToApplicability(branch, m, formalType, invoc));	1✔
170	}
171
172	return true;	1✔
173	}
174
175
176	/**
177	* Returns null if the method reference is inexact.
178	*/
179	static @Nullable JMethodSig getExactMethod(MethodRefMirror mref) {
180	JMethodSig cached = mref.getCachedExactMethod();	1✔
181
182	if (cached == null) { // inexact	1✔
183	return null;	1✔
184	}
185
186	if (cached.getTypeSystem().UNRESOLVED_METHOD == cached) {	1✔
187	cached = computeExactMethod(mref);	1✔
188	mref.setCachedExactMethod(cached); // set to null if inexact, sentinel is UNRESOLVED_METHOD	1✔
189	}
190
191	return cached;	1✔
192	}
193
194	private static @Nullable JMethodSig computeExactMethod(MethodRefMirror mref) {
195
196
197	final @Nullable JTypeMirror lhs = mref.getLhsIfType();	1✔
198
199	List<JMethodSig> accessible;
200
201	if (mref.isConstructorRef()) {	1✔
202	if (lhs == null) {	1!
203	// ct error, already reported as a missing symbol in our system
204	return null;	×
205	} else if (lhs.isArray()) {	1✔
206	// A method reference expression of the form ArrayType :: new is always exact.
207	// But: If a method reference expression has the form ArrayType :: new, then ArrayType
208	// must denote a type that is reifiable (§4.7), or a compile-time error occurs.
209	if (lhs.isReifiable()) {	1!
210	JTypeDeclSymbol symbol = lhs.getSymbol();	1✔
211
212	assert symbol instanceof JClassSymbol && ((JClassSymbol) symbol).isArray()	1!
213	: "Reifiable array should present a symbol! " + lhs;
214
215	return lhs.getConstructors().get(0);	1✔
216	} else {
217	// todo compile time error
218	return null;	×
219	}
220	} else {
221	if (lhs.isRaw() \|\| !(lhs instanceof JClassType)) {	1!
222	return null;	1✔
223	}
224
225	accessible = TypeOps.filterAccessible(lhs.getConstructors(),	1✔
226	mref.getEnclosingType().getSymbol());	1✔
227	}
228	} else {
229	JClassType enclosing = mref.getEnclosingType();	1✔
230	accessible = mref.getTypeToSearch()	1✔
231	.streamMethods(TypeOps.accessibleMethodFilter(mref.getMethodName(), enclosing.getSymbol()))	1✔
232	.collect(OverloadSet.collectMostSpecific(enclosing));	1✔
233	}
234
235	if (accessible.size() == 1) {	1✔
236	JMethodSig candidate = accessible.get(0);	1✔
237	if (candidate.isVarargs()	1!
238	\|\| candidate.isGeneric() && mref.getExplicitTypeArguments().isEmpty()) {	1✔
239	return null;	1✔
240	}
241
242	candidate = candidate.subst(Substitution.mapping(candidate.getTypeParameters(), mref.getExplicitTypeArguments()));	1✔
243
244	if (lhs != null && lhs.isRaw()) {	1✔
245	// can be raw if the method doesn't mention type vars
246	// of the original owner, ie the erased method is the
247	// same as the generic method.
248	JClassType lhsClass = (JClassType) candidate.getDeclaringType();	1✔
249	JMethodSig unerased = cast(cast(candidate).withOwner(lhsClass.getGenericTypeDeclaration())).originalMethod();	1✔
250	if (TypeOps.mentionsAny(unerased, lhsClass.getFormalTypeParams())) {	1✔
251	return null;	1✔
252	}
253	}
254
255	// For exact method references, the return type is Class<? extends T> (no erasure).
256	// So it's mref::getTypeToSearch and not mref.getTypeToSearch()::getErasure
257	return adaptGetClass(candidate, mref::getTypeToSearch);	1✔
258	} else {
259	return null;	1✔
260	}
261	}
262
263
264	// for inexact method refs
265	@Nullable MethodCtDecl findInexactMethodRefCompileTimeDecl(MethodRefMirror mref, JMethodSig targetType) {
266	// https://docs.oracle.com/javase/specs/jls/se14/html/jls-15.html#jls-15.13.1
267
268	JTypeMirror lhsIfType = mref.getLhsIfType();	1✔
269	boolean acceptLowerArity = lhsIfType != null && lhsIfType.isClassOrInterface() && !mref.isConstructorRef();	1!
270
271	MethodCallSite site1 = infer.newCallSite(methodRefAsInvocation(mref, targetType, false), null);	1✔
272	site1.setLogging(!acceptLowerArity); // if we do only one search, then failure matters	1✔
273	MethodCtDecl ctd1 = infer.determineInvocationTypeOrFail(site1);	1✔
274	JMethodSig m1 = ctd1.getMethodType();	1✔
275
276	if (acceptLowerArity) {	1✔
277	// then we need to perform two searches, one with arity n, looking for static methods,
278	// one with n-1, looking for instance methods
279
280	MethodCallSite site2 = infer.newCallSite(methodRefAsInvocation(mref, targetType, true), null);	1✔
281	site2.setLogging(false);	1✔
282	MethodCtDecl ctd2 = infer.determineInvocationTypeOrFail(site2);	1✔
283	JMethodSig m2 = ctd2.getMethodType();	1✔
284
285	// If the first search produces a most specific method that is static,
286	// and the set of applicable methods produced by the second search
287	// contains no non-static methods, then the compile-time declaration
288	// is the most specific method of the first search.
289	if (m1 != ts.UNRESOLVED_METHOD && m1.isStatic() && (m2 == ts.UNRESOLVED_METHOD \|\| m2.isStatic())) {	1!
290	return ctd1;	1✔
291	} else if (m2 != ts.UNRESOLVED_METHOD && !m2.isStatic() && (m1 == ts.UNRESOLVED_METHOD \|\| !m1.isStatic())) {	1!
292	// Otherwise, if the set of applicable methods produced by the
293	// first search contains no static methods, and the second search
294	// produces a most specific method that is non-static, then the
295	// compile-time declaration is the most specific method of the second search.
296	return ctd2;	1✔
297	}
298
299	// Otherwise, there is no compile-time declaration.
300	return null;	1✔
301	} else if (m1 == ts.UNRESOLVED_METHOD \|\| m1.isStatic()) {	1!
302	// if the most specific applicable method is static, there is no compile-time declaration.
UNCOV 303	return null;	×
304	} else {
305	// Otherwise, the compile-time declaration is the most specific applicable method.
306	return ctd1;	1✔
307	}
308	}
309
310	static InvocationMirror methodRefAsInvocation(final MethodRefMirror mref, JMethodSig targetType, boolean asInstanceMethod) {
311	// the arguments are treated as if they were of the type
312	// of the formal parameters of the candidate
313	List<JTypeMirror> formals = targetType.getFormalParameters();	1✔
314	if (asInstanceMethod && !formals.isEmpty()) {	1✔
315	formals = formals.subList(1, formals.size()); // skip first param (receiver)	1✔
316	}
317
318	List<ExprMirror> arguments = CollectionUtil.map(	1✔
319	formals,
320	fi -> new ExprMirror() {	1✔
321
322	@Override
323	public void setInferredType(JTypeMirror mirror) {
324	// do nothing
325	}	1✔
326
327	@Override
328	public @Nullable JTypeMirror getInferredType() {
329	throw new UnsupportedOperationException();	×
330	}
331
332	@Override
333	public JavaNode getLocation() {
334	return mref.getLocation();	1✔
335	}
336
337	@Override
338	public JTypeMirror getStandaloneType() {
339	return fi;	1✔
340	}
341
342	@Override
343	public String toString() {
344	return "formal : " + fi;	×
345	}
346
347	@Override
348	public TypingContext getTypingContext() {
349	return mref.getTypingContext();	×
350	}
351
352	@Override
353	public boolean isEquivalentToUnderlyingAst() {
354	throw new UnsupportedOperationException("Cannot invoque isSemanticallyEquivalent on this mirror, it doesn't have a backing AST node: " + this);	×
355	}
356	}
357	);
358
359
360	return new InvocationMirror() {	1✔
361
362	private MethodCtDecl mt;
363
364	@Override
365	public JavaNode getLocation() {
366	return mref.getLocation();	×
367	}
368
369	@Override
370	public Iterable<JMethodSig> getAccessibleCandidates() {
371	return ExprOps.getAccessibleCandidates(mref, asInstanceMethod, targetType);	1✔
372	}
373
374	@Override
375	public JTypeMirror getErasedReceiverType() {
376	return mref.getTypeToSearch().getErasure();	×
377	}
378
379	@Override
380	public @Nullable JTypeMirror getReceiverType() {
381	return mref.getTypeToSearch();	1✔
382	}
383
384	@Override
385	public List<JTypeMirror> getExplicitTypeArguments() {
386	return mref.getExplicitTypeArguments();	1✔
387	}
388
389	@Override
390	public JavaNode getExplicitTargLoc(int i) {
391	throw new IndexOutOfBoundsException();	×
392	}
393
394	@Override
395	public String getName() {
396	return mref.getMethodName();	×
397	}
398
399	@Override
400	public List<ExprMirror> getArgumentExpressions() {
401	return arguments;	1✔
402	}
403
404	@Override
405	public int getArgumentCount() {
406	return arguments.size();	1✔
407	}
408
409	@Override
410	public void setCtDecl(MethodCtDecl methodType) {
411	this.mt = methodType;	1✔
412	}	1✔
413
414	@Override
415	public @Nullable MethodCtDecl getCtDecl() {
416	return mt;	1✔
417	}
418
419	JTypeMirror inferred;
420
421	@Override
422	public void setInferredType(JTypeMirror mirror) {
423	// todo is this useful for method refs?
424	inferred = mirror;	1✔
425	}	1✔
426
427	@Override
428	public JTypeMirror getInferredType() {
429	return inferred;	×
430	}
431
432	@Override
433	public @NonNull JClassType getEnclosingType() {
434	return mref.getEnclosingType();	×
435	}
436
437	@Override
438	public String toString() {
439	return "Method ref adapter (for " + mref + ")";	×
440	}
441
442	@Override
443	public TypingContext getTypingContext() {
444	return mref.getTypingContext();	×
445	}
446
447	@Override
448	public boolean isEquivalentToUnderlyingAst() {
449	throw new UnsupportedOperationException("Cannot invoque isSemanticallyEquivalent on this mirror, it doesn't have a backing AST node: " + this);	×
450	}
451	};
452	}
453
454	private static Iterable<JMethodSig> getAccessibleCandidates(MethodRefMirror mref, boolean asInstanceMethod, JMethodSig targetType) {
455	JMethodSig exactMethod = getExactMethod(mref);	1✔
456	if (exactMethod != null) {	1!
457	return Collections.singletonList(exactMethod);	×
458	} else {
459	final JTypeMirror actualTypeToSearch;
460	{
461	JTypeMirror typeToSearch = mref.getTypeToSearch();	1✔
462	if (typeToSearch.isArray() && mref.isConstructorRef()) {	1!
463	// ArrayType :: new
464	return typeToSearch.getConstructors();	×
465	} else if (typeToSearch instanceof JClassType && mref.isConstructorRef()) {	1!
466	// ClassType :: [TypeArguments] new
467	// TODO treatment of raw constructors is whacky
468	return TypeOps.lazyFilterAccessible(typeToSearch.getConstructors(), mref.getEnclosingType().getSymbol());	1✔
469	}
470
471	if (asInstanceMethod && typeToSearch.isRaw() && typeToSearch instanceof JClassType	1!
472	&& targetType.getArity() > 0) {	1!
473	// In the second search, if P1, ..., Pn is not empty
474	// and P1 is a subtype of ReferenceType, then the
475	// method reference expression is treated as if it were
476	// a method invocation expression with argument expressions
477	// of types P2, ..., Pn. If ReferenceType is a raw type,
478	// and there exists a parameterization of this type, G<...>,
479	// that is a supertype of P1, the type to search is the result
480	// of capture conversion (§5.1.10) applied to G<...>; otherwise,
481	// the type to search is the same as the type of the first search.
482
483	JClassType type = (JClassType) typeToSearch;	1✔
484	JTypeMirror p1 = targetType.getFormalParameters().get(0);	1✔
485	JTypeMirror asSuper = p1.getAsSuper(type.getSymbol());	1✔
486	if (asSuper != null && asSuper.isParameterizedType()) {	1!
487	typeToSearch = capture(asSuper);	1✔
488	}
489	}
490	actualTypeToSearch = typeToSearch;	1✔
491	}
492
493	// Primary :: [TypeArguments] Identifier
494	// ExpressionName :: [TypeArguments] Identifier
495	// super :: [TypeArguments] Identifier
496	// TypeName.super :: [TypeArguments] Identifier
497	// ReferenceType :: [TypeArguments] Identifier
498
499	boolean acceptsInstanceMethods = canUseInstanceMethods(actualTypeToSearch, targetType, mref);	1✔
500
501	Predicate<JMethodSymbol> prefilter = TypeOps.accessibleMethodFilter(mref.getMethodName(), mref.getEnclosingType().getSymbol())	1✔
502	.and(m -> Modifier.isStatic(m.getModifiers())	1✔
503	\|\| acceptsInstanceMethods);
504	return actualTypeToSearch.streamMethods(prefilter).collect(Collectors.toList());	1✔
505	}
506	}
507
508	private static boolean canUseInstanceMethods(JTypeMirror typeToSearch, JMethodSig sig, MethodRefMirror mref) {
509	// For example, if you write
510	// stringStream.map(Objects::toString),
511
512	// The type to search is Objects. But Objects inherits Object.toString(),
513	// which could not be called on a string (String.toString() != Objects.toString()).
514
515	if (mref.getLhsIfType() != null && !sig.getFormalParameters().isEmpty()) {	1✔
516	// ReferenceType :: [TypeArguments] Identifier
517	JTypeMirror firstFormal = sig.getFormalParameters().get(0);	1✔
518	return firstFormal.isSubtypeOf(typeToSearch);	1✔
519	}
520	return true;	1✔
521	}
522
523
524	/**
525	* Calls to {@link Object#getClass()} on a type {@code T} have type
526	* {@code Class<? extends \|T\|>}. If the selected method is that method, then
527	* we need to replace its return type (the symbol has return type {@link Object}).
528	*
529	* <p>For exact method reference expressions, the type is {@code <? extends T>} (no erasure).
530	*
531	* @param sig Selected signature
532	* @param replacementReturnType Lazily created, because in many cases it's not necessary
533	*
534	* @return Signature, adapted if it is {@link Object#getClass()}
535	*/
536	static JMethodSig adaptGetClass(JMethodSig sig, Supplier<JTypeMirror> replacementReturnType) {
537	TypeSystem ts = sig.getTypeSystem();	1✔
538	if ("getClass".equals(sig.getName()) && sig.getDeclaringType().equals(ts.OBJECT)) {	1!
539	return cast(cast(sig).withReturnType(getClassReturn(replacementReturnType.get(), ts))).markAsAdapted();	1✔
540	}
541	return sig;	1✔
542	}
543
544	private static JTypeMirror getClassReturn(JTypeMirror erasedReceiverType, TypeSystem ts) {
545	return ts.parameterise(ts.getClassSymbol(Class.class), listOf(ts.wildcard(true, erasedReceiverType)));	1✔
546	}
547
548	static boolean isContextDependent(JMethodSig m) {
549	m = cast(m).adaptedMethod();	1✔
550	return m.isGeneric() && TypeOps.mentionsAny(m.getReturnType(), m.getTypeParameters());	1✔
551	}
552	}

pmd / pmd / #4173

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous