#3966

Committed 18 Mar 2024 06:30PM UTC coverage: 48.674% (+0.01%) from 48.661%

Build # #3966

Build Type

push

github

Committed by

adangel

Commit Message

Merge pull request #4841 from adangel:issue-4817-UnusedPrivateMethod

[java] UnusedPrivateMethod - fix false positive with lambdas #4841

Run Details

32382 of 72833 branches covered (44.46%)

Branch coverage included in aggregate %.

30 of 33 new or added lines in 4 files covered. (90.91%)

21 existing lines in 4 files now uncovered.

68128 of 133664 relevant lines covered (50.97%)

0.51 hits per line

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

90.23

/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/types/internal/infer/InferenceContext.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.TypeOps.asList;
import static net.sourceforge.pmd.util.CollectionUtil.intersect;

import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

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

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.JTypeVisitable;
import net.sourceforge.pmd.lang.java.types.SubstVar;
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.internal.infer.ExprMirror.InvocationMirror.MethodCtDecl;
import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.CheckBound;
import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.PropagateAllBounds;
import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.PropagateBounds;
import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.SubstituteInst;
import net.sourceforge.pmd.lang.java.types.internal.infer.InferenceVar.BoundKind;
import net.sourceforge.pmd.lang.java.types.internal.infer.VarWalkStrategy.GraphWalk;

/**
 * Context of a type inference process. This object maintains a set of
 * unique inference variables. Inference variables maintain the set of
 * bounds that apply to them.
 */
final class InferenceContext {

    // ivar/ctx ids are globally unique, & repeatable in debug output if you do exactly the same run
    private static int varId = 0;
    private static int ctxId = 0;

    private final Map<InstantiationListener, Set<InferenceVar>> instantiationListeners = new HashMap<>();

    private final Set<InferenceVar> freeVars = new LinkedHashSet<>();
    private final Set<InferenceVar> inferenceVars = new LinkedHashSet<>();
    private final Deque<IncorporationAction> incorporationActions = new ArrayDeque<>();
    final TypeSystem ts;
    private final SupertypeCheckCache supertypeCheckCache;
    final TypeInferenceLogger logger;

    private Substitution mapping = Substitution.EMPTY;
    private @Nullable InferenceContext parent;
    private boolean needsUncheckedConversion;
    private final int id;

    /**
     * Create an inference context from a set of type variables to instantiate.
     * This creates inference vars and adds the initial bounds as described in
     *
     * https://docs.oracle.com/javase/specs/jls/se9/html/jls-18.html#jls-18.1.3
     *
     * under the purple rectangle.
     *
     * @param ts                  The global type system
     * @param supertypeCheckCache Super type check cache, shared by all
     *                            inference runs in the same compilation unit
     *                            (stored in {@link Infer}).
     * @param tvars               Initial tvars which will be turned
     *                            into ivars
     * @param logger              Logger for events related to ivar bounds
     */
    @SuppressWarnings("PMD.AssignmentToNonFinalStatic") // ctxId
    InferenceContext(TypeSystem ts, SupertypeCheckCache supertypeCheckCache, List<JTypeVar> tvars, TypeInferenceLogger logger) {
        this.ts = ts;
        this.supertypeCheckCache = supertypeCheckCache;
        this.logger = logger;
        this.id = ctxId++;

        for (JTypeVar p : tvars) {
            addVarImpl(p);
        }

        for (InferenceVar ivar : inferenceVars) {
            addPrimaryBound(ivar);
        }
    }

    public InferenceContext copy() {
        final InferenceContext copy = new InferenceContext(ts, supertypeCheckCache, Collections.emptyList(), logger);
        copy.freeVars.addAll(this.freeVars);
        copy.inferenceVars.addAll(this.inferenceVars);
        copy.incorporationActions.addAll(this.incorporationActions);
        copy.mapping = mapping; // mapping is immutable, so we can share it safely

        // recursively copy parents…
        if (this.parent != null) {
            copy.parent = this.parent.copy();
        }

        return copy;
    }

    public int getId() {
        return id;
    }

    private void addPrimaryBound(InferenceVar ivar) {
        for (JTypeMirror ui : asList(ivar.getBaseVar().getUpperBound())) {
            ivar.addPrimaryBound(BoundKind.UPPER, mapToIVars(ui));
        }
    }

    /** Add a variable to this context. */
    InferenceVar addVar(JTypeVar tvar) {
        InferenceVar ivar = addVarImpl(tvar);
        addPrimaryBound(ivar);

        for (InferenceVar otherIvar : inferenceVars) {
            // remove remaining occurrences of type params
            otherIvar.substBounds(this::mapToIVars);
        }
        return ivar;
    }

    /** Add a variable to this context. */
    private InferenceVar addVarImpl(@NonNull JTypeVar tvar) {
        InferenceVar ivar = new InferenceVar(this, tvar, varId++);
        freeVars.add(ivar);
        inferenceVars.add(ivar);
        mapping = mapping.plus(tvar, ivar);
        return ivar;
    }

    /**
     * Replace all type variables in the given type with corresponding
     * inference vars.
     */
    JTypeMirror mapToIVars(JTypeMirror t) {
        return TypeOps.subst(t, mapping);
    }

    /**
     * Replace all type variables in the given type with corresponding
     * inference vars.
     */
    JMethodSig mapToIVars(JMethodSig t) {
        return t.subst(mapping);
    }

    /**
     * Returns true if the type mentions no free inference variables.
     * This is what the JLS calls a "proper type".
     */
    boolean isGround(JTypeVisitable t) {
        return !TypeOps.mentionsAny(t, freeVars);
    }

    /**
     * Returns true if the type mentions no free inference variables.
     */
    boolean areAllGround(Collection<? extends JTypeVisitable> ts) {
        for (JTypeVisitable t : ts) {
            if (!isGround(t)) {
                return false;
            }
        }
        return true;
    }

    Set<InferenceVar> freeVarsIn(Iterable<? extends JTypeVisitable> types) {
        Set<InferenceVar> vars = new LinkedHashSet<>();
        for (InferenceVar ivar : freeVars) {
            for (JTypeVisitable t : types) {
                if (TypeOps.mentions(t, ivar)) {
                    vars.add(ivar);
                }
            }
        }
        return vars;
    }

    Set<InferenceVar> freeVarsIn(JTypeVisitable t) {
        return freeVarsIn(Collections.singleton(t));
    }

    /**
     * Replace instantiated inference vars with their instantiation in the given type.
     */
    JTypeMirror ground(JTypeMirror t) {
        return t.subst(InferenceContext::groundSubst);
    }

    JClassType ground(JClassType t) {
        return t.subst(InferenceContext::groundSubst);
    }

    /**
     * Replace instantiated inference vars with their instantiation in the given type.
     */
    JMethodSig ground(JMethodSig t) {
        return t.subst(InferenceContext::groundSubst);
    }

    void setNeedsUncheckedConversion() {
        this.needsUncheckedConversion = true;
    }

    /**
     * Whether incorporation/solving required an unchecked conversion.
     * This means the invocation type of the overload must be erased.
     *
     * @see MethodCtDecl#needsUncheckedConversion()
     */
    boolean needsUncheckedConversion() {
        return this.needsUncheckedConversion;
    }

    SupertypeCheckCache getSupertypeCheckCache() {
        return supertypeCheckCache;
    }

    private static JTypeMirror groundSubst(SubstVar var) {
        if (var instanceof InferenceVar) {
            JTypeMirror inst = ((InferenceVar) var).getInst();
            if (inst != null) {
                return inst;
            }
        }
        return var;
    }

    /**
     * Replace instantiated inference vars with their instantiation in the given type,
     * or else replace them with a failed type.
     */
    static JMethodSig finalGround(JMethodSig t) {
        return t.subst(s -> {
            if (!(s instanceof InferenceVar)) {
                return s;
            } else {
                InferenceVar ivar = (InferenceVar) s;
                return ivar.getInst() != null ? ivar.getInst() : s.getTypeSystem().ERROR;
            }
        });
    }

    /**
     * Copy variable in this inference context to the given context
     */
    void duplicateInto(final InferenceContext that) {
        that.inferenceVars.addAll(this.inferenceVars);
        that.freeVars.addAll(this.freeVars);
        that.incorporationActions.addAll(this.incorporationActions);
        that.instantiationListeners.putAll(this.instantiationListeners);

        this.parent = that;

        // propagate existing bounds into the new context
        for (InferenceVar freeVar : this.freeVars) {
            that.incorporationActions.add(new PropagateAllBounds(freeVar));
        }
    }


    void addInstantiationListener(Set<? extends JTypeMirror> relevantTypes, InstantiationListener listener) {
        Set<InferenceVar> free = freeVarsIn(relevantTypes);
        if (free.isEmpty()) {
            listener.onInstantiation(this);
            return;
        }
        instantiationListeners.put(listener, free);
    }

    /**
     * Call the listeners registered with {@link #addInstantiationListener(Set, InstantiationListener)}.
     * Listeners are used to perform deferred checks, like checking
     * compatibility of a formal parameter with an expression when the
     * formal parameter is not ground.
     */
    void callListeners() {
        if (instantiationListeners.isEmpty()) {
            return;
        }
        Set<InferenceVar> solved = new LinkedHashSet<>(inferenceVars);
        solved.removeAll(freeVars);


        for (Entry<InstantiationListener, Set<InferenceVar>> entry : new LinkedHashSet<>(instantiationListeners.entrySet())) {
            if (solved.containsAll(entry.getValue())) {
                try {
                    entry.getKey().onInstantiation(this);
                } catch (ResolutionFailedException ignored) {
                    // that is a compile-time error, but that
                    // shouldn't affect PMD

                    // This can happen eg when an assertion fails in a
                    // subcontext that depends on this one, which is waiting
                    // for more inference to happen

                    // TODO investigate
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    instantiationListeners.remove(entry.getKey());
                }
            }
        }
    }

    Set<InferenceVar> getFreeVars() {
        return Collections.unmodifiableSet(freeVars);
    }

    private void onVarInstantiated(InferenceVar ivar) {
        if (parent != null) {
            parent.onVarInstantiated(ivar);
            return;
        }

        logger.ivarInstantiated(this, ivar, ivar.getInst());

        incorporationActions.addFirst(new SubstituteInst(ivar, ivar.getInst()) {
            @Override
            public void apply(InferenceContext ctx) {
                freeVars.removeIf(it -> it.getInst() != null);
                super.apply(ctx);
            }
        });
    }


    void onBoundAdded(InferenceVar ivar, BoundKind kind, JTypeMirror bound, boolean isPrimary) {
        // guard against α <: Object
        // all variables have it, it's useless to propagate it
        if (kind != BoundKind.UPPER || bound != ts.OBJECT) { // NOPMD CompareObjectsWithEquals
            if (parent != null) {
                parent.onBoundAdded(ivar, kind, bound, isPrimary);
                return;
            }

            logger.boundAdded(this, ivar, kind, bound, isPrimary);

            incorporationActions.add(new CheckBound(ivar, kind, bound));
            incorporationActions.add(new PropagateBounds(ivar, kind, bound));
        }
    }

    void onIvarMerged(InferenceVar prev, InferenceVar delegate) {
        if (parent != null) {
            parent.onIvarMerged(prev, delegate);
            return;
        }

        logger.ivarMerged(this, prev, delegate);

        mapping = mapping.plus(prev.getBaseVar(), delegate);
        incorporationActions.addFirst(new SubstituteInst(prev, delegate));
    }

    /**
     * Runs the incorporation hooks registered for the free vars.
     *
     * @throws ResolutionFailedException If some propagated bounds are incompatible
     */
    void incorporate() {
        if (incorporationActions.isEmpty()) {
            return;
        }

        IncorporationAction hook = incorporationActions.pollFirst();
        while (hook != null) {

            if (hook.doApplyToInstVar || hook.ivar.getInst() == null) {
                hook.apply(this);
            }

            hook = incorporationActions.pollFirst();
        }
    }

    /**
     * @throws ResolutionFailedException Because it calls {@link #incorporate()}
     */
    void solve() {
        solve(false);
    }

    boolean solve(boolean onlyBoundedVars) {
        return solve(new GraphWalk(this, onlyBoundedVars));
    }

    /**
     * Solve a single var, this does not solve its dependencies, so that
     * if some bounds are not ground, instantiation will be wrong.
     */
    void solve(InferenceVar var) {
        solve(new GraphWalk(var));
    }

    private boolean solve(VarWalkStrategy walker) {
        incorporate();

        while (walker.hasNext()) {

            Set<InferenceVar> varsToSolve = walker.next();

            boolean progress = true;
            //repeat until all variables are solved
            outer:
            while (!intersect(freeVars, varsToSolve).isEmpty() && progress) {
                progress = false;
                for (List<ReductionStep> wave : ReductionStep.WAVES) {
                    if (solveBatchProgressed(varsToSolve, wave)) {
                        incorporate();
                        progress = true;
                        callListeners();
                        continue outer;
                    }
                }
            }
        }
        return freeVars.isEmpty();
    }

    /**
     * Tries to solve as much of varsToSolve as possible using some reduction steps.
     * Returns the set of solved variables during this step.
     */
    private boolean solveBatchProgressed(Set<InferenceVar> varsToSolve, List<ReductionStep> wave) {
        for (InferenceVar ivar : intersect(varsToSolve, freeVars)) {
            for (ReductionStep step : wave) {
                if (step.accepts(ivar, this)) {
                    ivar.setInst(step.solve(ivar, this));
                    onVarInstantiated(ivar);
                    return true;
                }
            }
        }

        return false;
    }

    public boolean isEmpty() {
        return inferenceVars.isEmpty();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("Inference context " + getId()).append('\n');
        for (InferenceVar ivar : inferenceVars) {
            sb.append(ivar);
            if (ivar.getInst() != null) {
                sb.append(" := ").append(ivar.getInst()).append('\n');
            } else {
                ivar.formatBounds(sb).append('\n');
            }
        }

        return sb.toString();
    }

    /** A callback called when a set of variables have been solved. */
    public interface InstantiationListener {

        /**
         * Called when the set of dependencies provided to {@link #addInstantiationListener(Set, InstantiationListener)}
         * have been solved. The parameter is not necessarily the context
         * on which this has been registered, because contexts adopt the
         * inference variables of their children in some cases, to solve
         * them together. Use {@link #ground(JClassType)} with the context
         * parameter, not the context on which the callback was registered.
         */
        void onInstantiation(InferenceContext solvedCtx);

    }
}

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
8	import static net.sourceforge.pmd.lang.java.types.TypeOps.asList;
9	import static net.sourceforge.pmd.util.CollectionUtil.intersect;
10
11	import java.util.ArrayDeque;
12	import java.util.Collection;
13	import java.util.Collections;
14	import java.util.Deque;
15	import java.util.HashMap;
16	import java.util.LinkedHashSet;
17	import java.util.List;
18	import java.util.Map;
19	import java.util.Map.Entry;
20	import java.util.Set;
21
22	import org.checkerframework.checker.nullness.qual.NonNull;
23	import org.checkerframework.checker.nullness.qual.Nullable;
24
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.JTypeVisitable;
30	import net.sourceforge.pmd.lang.java.types.SubstVar;
31	import net.sourceforge.pmd.lang.java.types.Substitution;
32	import net.sourceforge.pmd.lang.java.types.TypeOps;
33	import net.sourceforge.pmd.lang.java.types.TypeSystem;
34	import net.sourceforge.pmd.lang.java.types.internal.infer.ExprMirror.InvocationMirror.MethodCtDecl;
35	import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.CheckBound;
36	import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.PropagateAllBounds;
37	import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.PropagateBounds;
38	import net.sourceforge.pmd.lang.java.types.internal.infer.IncorporationAction.SubstituteInst;
39	import net.sourceforge.pmd.lang.java.types.internal.infer.InferenceVar.BoundKind;
40	import net.sourceforge.pmd.lang.java.types.internal.infer.VarWalkStrategy.GraphWalk;
41
42	/**
43	* Context of a type inference process. This object maintains a set of
44	* unique inference variables. Inference variables maintain the set of
45	* bounds that apply to them.
46	*/
47	final class InferenceContext {
48
49	// ivar/ctx ids are globally unique, & repeatable in debug output if you do exactly the same run
50	private static int varId = 0;	1✔
51	private static int ctxId = 0;	1✔
52
53	private final Map<InstantiationListener, Set<InferenceVar>> instantiationListeners = new HashMap<>();	1✔
54
55	private final Set<InferenceVar> freeVars = new LinkedHashSet<>();	1✔
56	private final Set<InferenceVar> inferenceVars = new LinkedHashSet<>();	1✔
57	private final Deque<IncorporationAction> incorporationActions = new ArrayDeque<>();	1✔
58	final TypeSystem ts;
59	private final SupertypeCheckCache supertypeCheckCache;
60	final TypeInferenceLogger logger;
61
62	private Substitution mapping = Substitution.EMPTY;	1✔
63	private @Nullable InferenceContext parent;
64	private boolean needsUncheckedConversion;
65	private final int id;
66
67	/**
68	* Create an inference context from a set of type variables to instantiate.
69	* This creates inference vars and adds the initial bounds as described in
70	*
71	* https://docs.oracle.com/javase/specs/jls/se9/html/jls-18.html#jls-18.1.3
72	*
73	* under the purple rectangle.
74	*
75	* @param ts The global type system
76	* @param supertypeCheckCache Super type check cache, shared by all
77	* inference runs in the same compilation unit
78	* (stored in {@link Infer}).
79	* @param tvars Initial tvars which will be turned
80	* into ivars
81	* @param logger Logger for events related to ivar bounds
82	*/
83	@SuppressWarnings("PMD.AssignmentToNonFinalStatic") // ctxId
84	InferenceContext(TypeSystem ts, SupertypeCheckCache supertypeCheckCache, List<JTypeVar> tvars, TypeInferenceLogger logger) {	1✔
85	this.ts = ts;	1✔
86	this.supertypeCheckCache = supertypeCheckCache;	1✔
87	this.logger = logger;	1✔
88	this.id = ctxId++;	1✔
89
90	for (JTypeVar p : tvars) {	1✔
91	addVarImpl(p);	1✔
92	}	1✔
93
94	for (InferenceVar ivar : inferenceVars) {	1✔
95	addPrimaryBound(ivar);	1✔
96	}	1✔
97	}	1✔
98
99	public InferenceContext copy() {
100	final InferenceContext copy = new InferenceContext(ts, supertypeCheckCache, Collections.emptyList(), logger);	1✔
101	copy.freeVars.addAll(this.freeVars);	1✔
102	copy.inferenceVars.addAll(this.inferenceVars);	1✔
103	copy.incorporationActions.addAll(this.incorporationActions);	1✔
104	copy.mapping = mapping; // mapping is immutable, so we can share it safely	1✔
105
106	// recursively copy parents…
107	if (this.parent != null) {	1!
NEW 108	copy.parent = this.parent.copy();	×
109	}
110
111	return copy;	1✔
112	}
113
114	public int getId() {
115	return id;	×
116	}
117
118	private void addPrimaryBound(InferenceVar ivar) {
119	for (JTypeMirror ui : asList(ivar.getBaseVar().getUpperBound())) {	1✔
120	ivar.addPrimaryBound(BoundKind.UPPER, mapToIVars(ui));	1✔
121	}	1✔
122	}	1✔
123
124	/** Add a variable to this context. */
125	InferenceVar addVar(JTypeVar tvar) {
126	InferenceVar ivar = addVarImpl(tvar);	1✔
127	addPrimaryBound(ivar);	1✔
128
129	for (InferenceVar otherIvar : inferenceVars) {	1✔
130	// remove remaining occurrences of type params
131	otherIvar.substBounds(this::mapToIVars);	1✔
132	}	1✔
133	return ivar;	1✔
134	}
135
136	/** Add a variable to this context. */
137	private InferenceVar addVarImpl(@NonNull JTypeVar tvar) {
138	InferenceVar ivar = new InferenceVar(this, tvar, varId++);	1✔
139	freeVars.add(ivar);	1✔
140	inferenceVars.add(ivar);	1✔
141	mapping = mapping.plus(tvar, ivar);	1✔
142	return ivar;	1✔
143	}
144
145	/**
146	* Replace all type variables in the given type with corresponding
147	* inference vars.
148	*/
149	JTypeMirror mapToIVars(JTypeMirror t) {
150	return TypeOps.subst(t, mapping);	1✔
151	}
152
153	/**
154	* Replace all type variables in the given type with corresponding
155	* inference vars.
156	*/
157	JMethodSig mapToIVars(JMethodSig t) {
158	return t.subst(mapping);	1✔
159	}
160
161	/**
162	* Returns true if the type mentions no free inference variables.
163	* This is what the JLS calls a "proper type".
164	*/
165	boolean isGround(JTypeVisitable t) {
166	return !TypeOps.mentionsAny(t, freeVars);	1✔
167	}
168
169	/**
170	* Returns true if the type mentions no free inference variables.
171	*/
172	boolean areAllGround(Collection<? extends JTypeVisitable> ts) {
173	for (JTypeVisitable t : ts) {	1✔
174	if (!isGround(t)) {	1✔
175	return false;	1✔
176	}
177	}	1✔
178	return true;	1✔
179	}
180
181	Set<InferenceVar> freeVarsIn(Iterable<? extends JTypeVisitable> types) {
182	Set<InferenceVar> vars = new LinkedHashSet<>();	1✔
183	for (InferenceVar ivar : freeVars) {	1✔
184	for (JTypeVisitable t : types) {	1✔
185	if (TypeOps.mentions(t, ivar)) {	1✔
186	vars.add(ivar);	1✔
187	}
188	}	1✔
189	}	1✔
190	return vars;	1✔
191	}
192
193	Set<InferenceVar> freeVarsIn(JTypeVisitable t) {
194	return freeVarsIn(Collections.singleton(t));	1✔
195	}
196
197	/**
198	* Replace instantiated inference vars with their instantiation in the given type.
199	*/
200	JTypeMirror ground(JTypeMirror t) {
201	return t.subst(InferenceContext::groundSubst);	1✔
202	}
203
204	JClassType ground(JClassType t) {
205	return t.subst(InferenceContext::groundSubst);	1✔
206	}
207
208	/**
209	* Replace instantiated inference vars with their instantiation in the given type.
210	*/
211	JMethodSig ground(JMethodSig t) {
212	return t.subst(InferenceContext::groundSubst);	1✔
213	}
214
215	void setNeedsUncheckedConversion() {
216	this.needsUncheckedConversion = true;	1✔
217	}	1✔
218
219	/**
220	* Whether incorporation/solving required an unchecked conversion.
221	* This means the invocation type of the overload must be erased.
222	*
223	* @see MethodCtDecl#needsUncheckedConversion()
224	*/
225	boolean needsUncheckedConversion() {
226	return this.needsUncheckedConversion;	1✔
227	}
228
229	SupertypeCheckCache getSupertypeCheckCache() {
230	return supertypeCheckCache;	1✔
231	}
232
233	private static JTypeMirror groundSubst(SubstVar var) {
234	if (var instanceof InferenceVar) {	1✔
235	JTypeMirror inst = ((InferenceVar) var).getInst();	1✔
236	if (inst != null) {	1✔
237	return inst;	1✔
238	}
239	}
240	return var;	1✔
241	}
242
243	/**
244	* Replace instantiated inference vars with their instantiation in the given type,
245	* or else replace them with a failed type.
246	*/
247	static JMethodSig finalGround(JMethodSig t) {
248	return t.subst(s -> {	1✔
249	if (!(s instanceof InferenceVar)) {	1✔
250	return s;	1✔
251	} else {
252	InferenceVar ivar = (InferenceVar) s;	1✔
253	return ivar.getInst() != null ? ivar.getInst() : s.getTypeSystem().ERROR;	1!
254	}
255	});
256	}
257
258	/**
259	* Copy variable in this inference context to the given context
260	*/
261	void duplicateInto(final InferenceContext that) {
262	that.inferenceVars.addAll(this.inferenceVars);	1✔
263	that.freeVars.addAll(this.freeVars);	1✔
264	that.incorporationActions.addAll(this.incorporationActions);	1✔
265	that.instantiationListeners.putAll(this.instantiationListeners);	1✔
266
267	this.parent = that;	1✔
268
269	// propagate existing bounds into the new context
270	for (InferenceVar freeVar : this.freeVars) {	1✔
271	that.incorporationActions.add(new PropagateAllBounds(freeVar));	1✔
272	}	1✔
273	}	1✔
274
275
276	void addInstantiationListener(Set<? extends JTypeMirror> relevantTypes, InstantiationListener listener) {
277	Set<InferenceVar> free = freeVarsIn(relevantTypes);	1✔
278	if (free.isEmpty()) {	1✔
279	listener.onInstantiation(this);	1✔
280	return;	1✔
281	}
282	instantiationListeners.put(listener, free);	1✔
283	}	1✔
284
285	/**
286	* Call the listeners registered with {@link #addInstantiationListener(Set, InstantiationListener)}.
287	* Listeners are used to perform deferred checks, like checking
288	* compatibility of a formal parameter with an expression when the
289	* formal parameter is not ground.
290	*/
291	void callListeners() {
292	if (instantiationListeners.isEmpty()) {	1✔
293	return;	1✔
294	}
295	Set<InferenceVar> solved = new LinkedHashSet<>(inferenceVars);	1✔
296	solved.removeAll(freeVars);	1✔
297
298
299	for (Entry<InstantiationListener, Set<InferenceVar>> entry : new LinkedHashSet<>(instantiationListeners.entrySet())) {	1✔
300	if (solved.containsAll(entry.getValue())) {	1✔
301	try {
302	entry.getKey().onInstantiation(this);	1✔
303	} catch (ResolutionFailedException ignored) {	1✔
304	// that is a compile-time error, but that
305	// shouldn't affect PMD
306
307	// This can happen eg when an assertion fails in a
308	// subcontext that depends on this one, which is waiting
309	// for more inference to happen
310
311	// TODO investigate
312	} catch (Exception e) {	×
313	e.printStackTrace();	×
314	} finally {
315	instantiationListeners.remove(entry.getKey());	1✔
316	}
317	}
318	}	1✔
319	}	1✔
320
321	Set<InferenceVar> getFreeVars() {
322	return Collections.unmodifiableSet(freeVars);	1✔
323	}
324
325	private void onVarInstantiated(InferenceVar ivar) {
326	if (parent != null) {	1!
327	parent.onVarInstantiated(ivar);	×
328	return;	×
329	}
330
331	logger.ivarInstantiated(this, ivar, ivar.getInst());	1✔
332
333	incorporationActions.addFirst(new SubstituteInst(ivar, ivar.getInst()) {	1✔
334	@Override
335	public void apply(InferenceContext ctx) {
336	freeVars.removeIf(it -> it.getInst() != null);	1✔
337	super.apply(ctx);	1✔
338	}	1✔
339	});
340	}	1✔
341
342
343	void onBoundAdded(InferenceVar ivar, BoundKind kind, JTypeMirror bound, boolean isPrimary) {
344	// guard against α <: Object
345	// all variables have it, it's useless to propagate it
346	if (kind != BoundKind.UPPER \|\| bound != ts.OBJECT) { // NOPMD CompareObjectsWithEquals	1✔
347	if (parent != null) {	1✔
348	parent.onBoundAdded(ivar, kind, bound, isPrimary);	1✔
349	return;	1✔
350	}
351
352	logger.boundAdded(this, ivar, kind, bound, isPrimary);	1✔
353
354	incorporationActions.add(new CheckBound(ivar, kind, bound));	1✔
355	incorporationActions.add(new PropagateBounds(ivar, kind, bound));	1✔
356	}
357	}	1✔
358
359	void onIvarMerged(InferenceVar prev, InferenceVar delegate) {
360	if (parent != null) {	1✔
361	parent.onIvarMerged(prev, delegate);	1✔
362	return;	1✔
363	}
364
365	logger.ivarMerged(this, prev, delegate);	1✔
366
367	mapping = mapping.plus(prev.getBaseVar(), delegate);	1✔
368	incorporationActions.addFirst(new SubstituteInst(prev, delegate));	1✔
369	}	1✔
370
371	/**
372	* Runs the incorporation hooks registered for the free vars.
373	*
374	* @throws ResolutionFailedException If some propagated bounds are incompatible
375	*/
376	void incorporate() {
377	if (incorporationActions.isEmpty()) {	1✔
378	return;	1✔
379	}
380
381	IncorporationAction hook = incorporationActions.pollFirst();	1✔
382	while (hook != null) {	1✔
383
384	if (hook.doApplyToInstVar \|\| hook.ivar.getInst() == null) {	1✔
385	hook.apply(this);	1✔
386	}
387
388	hook = incorporationActions.pollFirst();	1✔
389	}
390	}	1✔
391
392	/**
393	* @throws ResolutionFailedException Because it calls {@link #incorporate()}
394	*/
395	void solve() {
396	solve(false);	1✔
397	}	1✔
398
399	boolean solve(boolean onlyBoundedVars) {
400	return solve(new GraphWalk(this, onlyBoundedVars));	1✔
401	}
402
403	/**
404	* Solve a single var, this does not solve its dependencies, so that
405	* if some bounds are not ground, instantiation will be wrong.
406	*/
407	void solve(InferenceVar var) {
408	solve(new GraphWalk(var));	×
409	}	×
410
411	private boolean solve(VarWalkStrategy walker) {
412	incorporate();	1✔
413
414	while (walker.hasNext()) {	1✔
415
416	Set<InferenceVar> varsToSolve = walker.next();	1✔
417
418	boolean progress = true;	1✔
419	//repeat until all variables are solved
420	outer:
421	while (!intersect(freeVars, varsToSolve).isEmpty() && progress) {	1!
422	progress = false;	1✔
423	for (List<ReductionStep> wave : ReductionStep.WAVES) {	1!
424	if (solveBatchProgressed(varsToSolve, wave)) {	1✔
425	incorporate();	1✔
426	progress = true;	1✔
427	callListeners();	1✔
428	continue outer;	1✔
429	}
430	}	1✔
431	}
432	}	1✔
433	return freeVars.isEmpty();	1✔
434	}
435
436	/**
437	* Tries to solve as much of varsToSolve as possible using some reduction steps.
438	* Returns the set of solved variables during this step.
439	*/
440	private boolean solveBatchProgressed(Set<InferenceVar> varsToSolve, List<ReductionStep> wave) {
441	for (InferenceVar ivar : intersect(varsToSolve, freeVars)) {	1✔
442	for (ReductionStep step : wave) {	1✔
443	if (step.accepts(ivar, this)) {	1✔
444	ivar.setInst(step.solve(ivar, this));	1✔
445	onVarInstantiated(ivar);	1✔
446	return true;	1✔
447	}
448	}	1✔
449	}	1✔
450
451	return false;	1✔
452	}
453
454	public boolean isEmpty() {
455	return inferenceVars.isEmpty();	1✔
456	}
457
458	@Override
459	public String toString() {
460	StringBuilder sb = new StringBuilder("Inference context " + getId()).append('\n');	×
461	for (InferenceVar ivar : inferenceVars) {	×
462	sb.append(ivar);	×
463	if (ivar.getInst() != null) {	×
464	sb.append(" := ").append(ivar.getInst()).append('\n');	×
465	} else {
466	ivar.formatBounds(sb).append('\n');	×
467	}
468	}	×
469
470	return sb.toString();	×
471	}
472
473	/** A callback called when a set of variables have been solved. */
474	public interface InstantiationListener {
475
476	/**
477	* Called when the set of dependencies provided to {@link #addInstantiationListener(Set, InstantiationListener)}
478	* have been solved. The parameter is not necessarily the context
479	* on which this has been registered, because contexts adopt the
480	* inference variables of their children in some cases, to solve
481	* them together. Use {@link #ground(JClassType)} with the context
482	* parameter, not the context on which the callback was registered.
483	*/
484	void onInstantiation(InferenceContext solvedCtx);
485
486	}
487	}

pmd / pmd / #3966

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