4268

Committed 15 Dec 2024 04:58PM UTC coverage: 77.692%. Remained the same

Build # 4268

Build Type

push

github

Committed by

adangel

Commit Message

[java] Fix #5096 - StackOverflowError with recursively bounded tvar (#5387)

Merge pull request #5387 from oowekyala:issue5096-stackoverflow

Run Details

17293 of 23198 branches covered (74.55%)

Branch coverage included in aggregate %.

37 of 47 new or added lines in 3 files covered. (78.72%)

1 existing line in 1 file now uncovered.

38041 of 48024 relevant lines covered (79.21%)

0.8 hits per line

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

80.24

/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/types/TypeVarImpl.java

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

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

import static net.sourceforge.pmd.lang.java.types.TypeConversion.capture;

import java.util.Objects;
import java.util.function.Function;

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

import net.sourceforge.pmd.lang.java.symbols.JTypeParameterSymbol;
import net.sourceforge.pmd.lang.java.symbols.SymbolicValue.SymAnnot;

@SuppressWarnings("PMD.CompareObjectsWithEquals")
abstract class TypeVarImpl implements JTypeVar {


    final TypeSystem ts;
    JTypeMirror upperBound;

    /**
     * These are only the type annotations on a usage of the variable.
     * Annotations on the declaration of the tparam are not considered.
     */
    final PSet<SymAnnot> typeAnnots;

    // constructor only for the captured version.
    private TypeVarImpl(TypeSystem ts, PSet<SymAnnot> typeAnnots) {
        this.ts = ts;
        this.typeAnnots = Objects.requireNonNull(typeAnnots);
    }

    @Override
    public PSet<SymAnnot> getTypeAnnotations() {
        return typeAnnots;
    }

    @Override
    public TypeSystem getTypeSystem() {
        return ts;
    }

    @Override
    public JTypeMirror getErasure() {
        return getUpperBound().getErasure();
    }

    @Override
    public String toString() {
        return TypePrettyPrint.prettyPrint(this);
    }

    /**
     * Returns a fresh type variable, whose bounds will be initialised by
     * the capture conversion algo in {@link TypeConversion#capture(JTypeMirror)}.
     * Captured variables use reference identity as equality relation.
     */
    static TypeVarImpl.CapturedTypeVar freshCapture(@NonNull JWildcardType wildcard) {
        return new CapturedTypeVar(wildcard, wildcard.getTypeAnnotations());
    }

    /**
     * Capture a type variable, that is, capture its bounds if needed.
     * This is necessary because those bounds contributes to the methods
     * of the type variable.
     * Eg in {@code <C extends Collection<? super X>>} the methods available
     * in C may mention the type parameter of Collection. But this is a
     * wildcard `? super X` that needs to be replaced by a capture variable.
     *
     * @param tv a type var
     */
    static JTypeVar tvarCapture(@NonNull JTypeVar tv) {
        if (tv.isCaptured()) {
            return tv;
        }
        // Need to capture the bounds because those bounds contributes the methods of the tvar.
        // Eg in `<C extends Collection<? super X>>` the methods available in C may mention the type
        // parameter of collection. But this is a wildcard `? super X` that needs to be captured.
        JTypeMirror upperBoundCap = capture(tv.getUpperBound());
        JTypeMirror lowerBoundCap = capture(tv.getLowerBound());
        if (upperBoundCap == tv.getUpperBound() && lowerBoundCap == tv.getLowerBound()) {
            // no change
            return tv;
        }
        // We will return a new var.
        CapturedTypeVar newTv = new CapturedTypeVar(tv, upperBoundCap, lowerBoundCap, tv.getTypeAnnotations());

        // We have to update the bounds again, to uphold recursive bounds. Eg if you have the following:
        //    class C<T extends C<? extends T>>
        // then capturing T in the body of the class C should produce a new capture var, call it T2,
        // which has captured bounds. The upper bound of T2 should be
        //  capture(C<? extends T2>)
        // and notice that here it's T2 and not T, otherwise the recursive bound is
        // not preserved by capture. So this last update is there to map T to T2 (ie, tv to newTv).
        newTv.upperBound = upperBoundCap.subst(sv -> updateBounds(tv, sv, newTv));
        newTv.lowerBound = lowerBoundCap.subst(sv -> updateBounds(tv, sv, newTv));
        return newTv;
    }

    private static SubstVar updateBounds(JTypeVar tv, SubstVar sv, CapturedTypeVar newTv) {
        if (sv == tv) {
            return newTv;
        } else if (sv instanceof JTypeVar) {
            return ((JTypeVar) sv).substInBounds(sv2 -> {
                if (sv2 == tv) {
                    return newTv;
                }
                return sv2;
            });
        }
        return sv;
    }

    static final class RegularTypeVar extends TypeVarImpl {

        private final @NonNull JTypeParameterSymbol symbol;

        RegularTypeVar(TypeSystem ts, @NonNull JTypeParameterSymbol symbol, PSet<SymAnnot> typeAnnots) {
            super(ts, typeAnnots);
            this.symbol = symbol;
        }

        private RegularTypeVar(RegularTypeVar base, PSet<SymAnnot> typeAnnots) {
            this(base.ts, base.symbol, typeAnnots);
            this.upperBound = base.upperBound;
        }

        @Override
        public boolean isCaptured() {
            return false;
        }

        @Override
        public @NonNull JTypeMirror getLowerBound() {
            return ts.NULL_TYPE;
        }

        @Override
        public @NonNull JTypeParameterSymbol getSymbol() {
            return symbol;
        }

        @Override
        public @NonNull String getName() {
            return symbol.getSimpleName();
        }

        @Override
        public @NonNull JTypeMirror getUpperBound() {
            if (upperBound == null) {
                upperBound = symbol.computeUpperBound();
            }
            return upperBound;
        }

        @Override
        public JTypeVar withUpperBound(@NonNull JTypeMirror newUB) {
            RegularTypeVar tv = new RegularTypeVar(this, this.typeAnnots);
            tv.upperBound = newUB;
            return tv;
        }


        @Override
        public JTypeVar withAnnotations(PSet<SymAnnot> newTypeAnnots) {
            if (newTypeAnnots.isEmpty() && this.typeAnnots.isEmpty()) {
                return this;
            }
            return new RegularTypeVar(this, newTypeAnnots);
        }

        @Override
        public JTypeVar substInBounds(Function<? super SubstVar, ? extends @NonNull JTypeMirror> substitution) {
            if (Substitution.isEmptySubst(substitution)) {
                return this;
            }
            JTypeMirror newBound = getUpperBound().subst(substitution);
            if (newBound == upperBound) {
                return this;
            }
            RegularTypeVar newTVar = new RegularTypeVar(this.ts, this.symbol, this.getTypeAnnotations());
            newTVar.upperBound = newBound;
            return newTVar;
        }

        @Override
        public JTypeVar cloneWithBounds(JTypeMirror lower, JTypeMirror upper) {
            throw new UnsupportedOperationException("Not a capture variable");
        }

        @Override
        public boolean isCaptureOf(JWildcardType wildcard) {
            return false;
        }

        @Override
        public @Nullable JWildcardType getCapturedOrigin() {
            return null;
        }

        // we only compare the symbol
        // the point is to make tvars whose bound was substed equal to the original
        // tvar, for substs to work repeatedly. Maybe improving how JMethodSig works
        // would remove the need for that
        // Eg it would be nice to conceptualize JMethodSig as just a method symbol +
        // a substitution mapping type params in scope at that point to actual types
        // The problem is that we may want to subst it with type vars, and then use
        // those

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            RegularTypeVar that = (RegularTypeVar) o;
            return symbol.equals(that.symbol);
        }

        @Override
        public int hashCode() {
            return symbol.hashCode();
        }
    }

    static final class CapturedTypeVar extends TypeVarImpl {

        private static final int PRIME = 997;  // largest prime less than 1000

        private final @Nullable JWildcardType wildcard;
        private final @Nullable JTypeVar tvar;

        private JTypeMirror upperBound;
        private JTypeMirror lowerBound;

        private CapturedTypeVar(@NonNull JWildcardType wild, PSet<SymAnnot> typeAnnots) {
            this(wild, wild.asLowerBound(), wild.asUpperBound(), typeAnnots);
        }

        private CapturedTypeVar(@Nullable JWildcardType wild, @NonNull JTypeMirror lower, @NonNull JTypeMirror upper, PSet<SymAnnot> typeAnnots) {
            super(lower.getTypeSystem(), typeAnnots);
            this.upperBound = upper;
            this.lowerBound = lower;
            this.wildcard = wild;
            this.tvar = null;
        }

        private CapturedTypeVar(@Nullable JTypeVar tvar, @NonNull JTypeMirror lower, @NonNull JTypeMirror upper, PSet<SymAnnot> typeAnnots) {
            super(lower.getTypeSystem(), typeAnnots);
            this.upperBound = upper;
            this.lowerBound = lower;
            this.tvar = tvar;
            this.wildcard = null;
        }

        private CapturedTypeVar(@Nullable JTypeVar tvar, JWildcardType wild, @NonNull JTypeMirror lower, @NonNull JTypeMirror upper, PSet<SymAnnot> typeAnnots) {
            super(lower.getTypeSystem(), typeAnnots);
            this.upperBound = upper;
            this.lowerBound = lower;
            this.tvar = tvar;
            this.wildcard = wild;
        }

        void setUpperBound(@NonNull JTypeMirror upperBound) {
            this.upperBound = upperBound;
        }


        void setLowerBound(@NonNull JTypeMirror lowerBound) {
            this.lowerBound = lowerBound;
        }

        @Override
        public boolean equals(Object o) {
            return this == o || o instanceof CaptureMatcher && o.equals(this);
        }

        @Override
        public int hashCode() { // NOPMD UselessOverridingMethod
            return super.hashCode();
        }

        @Override
        public boolean isCaptured() {
            return true;
        }

        @Override
        public boolean isCaptureOf(JWildcardType wildcard) {
            return this.wildcard != null && this.wildcard.equals(wildcard);
        }

        @Override
        public JWildcardType getCapturedOrigin() {
            return wildcard;
        }

        @Override
        public JTypeVar substInBounds(Function<? super SubstVar, ? extends @NonNull JTypeMirror> substitution) {
            JWildcardType wild = this.wildcard == null ? null : this.wildcard.subst(substitution);
            JTypeMirror lower = getLowerBound().subst(substitution);
            JTypeMirror upper = getUpperBound().subst(substitution);
            if (wild == this.wildcard && lower == this.lowerBound && upper == this.lowerBound) {
                return this;
            } else if (wild == null) {
                return new CapturedTypeVar(tvar, lower, upper, typeAnnots);
            }
            return new CapturedTypeVar(wild, lower, upper, getTypeAnnotations());
        }

        @Override
        public JTypeVar cloneWithBounds(JTypeMirror lower, JTypeMirror upper) {
            return new CapturedTypeVar(wildcard, lower, upper, getTypeAnnotations());
        }


        @Override
        public JTypeVar withAnnotations(PSet<SymAnnot> newTypeAnnots) {
            if (newTypeAnnots.isEmpty() && typeAnnots.isEmpty()) {
                return this;
            }
            return new CapturedTypeVar(tvar, wildcard, lowerBound, upperBound, newTypeAnnots);
        }

        @Override
        public JTypeVar withUpperBound(@NonNull JTypeMirror newUB) {
            throw new UnsupportedOperationException("This only needs to be implemented on regular type variables");
        }

        @Override
        public @NonNull JTypeMirror getUpperBound() {
            return upperBound;
        }

        @Override
        public @NonNull JTypeMirror getLowerBound() {
            return lowerBound;
        }

        @Override
        public @Nullable JTypeParameterSymbol getSymbol() {
            return tvar == null ? null : tvar.getSymbol();
        }

        @Override
        public @NonNull String getName() {
            Object captureOrigin = wildcard == null ? tvar : wildcard;
            return "capture#" + hashCode() % PRIME + " of " + captureOrigin;
        }
    }
}

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;
6
7	import static net.sourceforge.pmd.lang.java.types.TypeConversion.capture;
8
9	import java.util.Objects;
10	import java.util.function.Function;
11
12	import org.checkerframework.checker.nullness.qual.NonNull;
13	import org.checkerframework.checker.nullness.qual.Nullable;
14	import org.pcollections.PSet;
15
16	import net.sourceforge.pmd.lang.java.symbols.JTypeParameterSymbol;
17	import net.sourceforge.pmd.lang.java.symbols.SymbolicValue.SymAnnot;
18
19	@SuppressWarnings("PMD.CompareObjectsWithEquals")
20	abstract class TypeVarImpl implements JTypeVar {
21
22
23	final TypeSystem ts;
24	JTypeMirror upperBound;
25
26	/**
27	* These are only the type annotations on a usage of the variable.
28	* Annotations on the declaration of the tparam are not considered.
29	*/
30	final PSet<SymAnnot> typeAnnots;
31
32	// constructor only for the captured version.
33	private TypeVarImpl(TypeSystem ts, PSet<SymAnnot> typeAnnots) {	1✔
34	this.ts = ts;	1✔
35	this.typeAnnots = Objects.requireNonNull(typeAnnots);	1✔
36	}	1✔
37
38	@Override
39	public PSet<SymAnnot> getTypeAnnotations() {
40	return typeAnnots;	1✔
41	}
42
43	@Override
44	public TypeSystem getTypeSystem() {
45	return ts;	1✔
46	}
47
48	@Override
49	public JTypeMirror getErasure() {
50	return getUpperBound().getErasure();	1✔
51	}
52
53	@Override
54	public String toString() {
55	return TypePrettyPrint.prettyPrint(this);	1✔
56	}
57
58	/**
59	* Returns a fresh type variable, whose bounds will be initialised by
60	* the capture conversion algo in {@link TypeConversion#capture(JTypeMirror)}.
61	* Captured variables use reference identity as equality relation.
62	*/
63	static TypeVarImpl.CapturedTypeVar freshCapture(@NonNull JWildcardType wildcard) {
64	return new CapturedTypeVar(wildcard, wildcard.getTypeAnnotations());	1✔
65	}
66
67	/**
68	* Capture a type variable, that is, capture its bounds if needed.
69	* This is necessary because those bounds contributes to the methods
70	* of the type variable.
71	* Eg in {@code <C extends Collection<? super X>>} the methods available
72	* in C may mention the type parameter of Collection. But this is a
73	* wildcard `? super X` that needs to be replaced by a capture variable.
74	*
75	* @param tv a type var
76	*/
77	static JTypeVar tvarCapture(@NonNull JTypeVar tv) {
78	if (tv.isCaptured()) {	1✔
79	return tv;	1✔
80	}
81	// Need to capture the bounds because those bounds contributes the methods of the tvar.
82	// Eg in `<C extends Collection<? super X>>` the methods available in C may mention the type
83	// parameter of collection. But this is a wildcard `? super X` that needs to be captured.
84	JTypeMirror upperBoundCap = capture(tv.getUpperBound());	1✔
85	JTypeMirror lowerBoundCap = capture(tv.getLowerBound());	1✔
86	if (upperBoundCap == tv.getUpperBound() && lowerBoundCap == tv.getLowerBound()) {	1!
87	// no change
88	return tv;	1✔
89	}
90	// We will return a new var.
91	CapturedTypeVar newTv = new CapturedTypeVar(tv, upperBoundCap, lowerBoundCap, tv.getTypeAnnotations());	1✔
92
93	// We have to update the bounds again, to uphold recursive bounds. Eg if you have the following:
94	// class C<T extends C<? extends T>>
95	// then capturing T in the body of the class C should produce a new capture var, call it T2,
96	// which has captured bounds. The upper bound of T2 should be
97	// capture(C<? extends T2>)
98	// and notice that here it's T2 and not T, otherwise the recursive bound is
99	// not preserved by capture. So this last update is there to map T to T2 (ie, tv to newTv).
100	newTv.upperBound = upperBoundCap.subst(sv -> updateBounds(tv, sv, newTv));	1✔
101	newTv.lowerBound = lowerBoundCap.subst(sv -> updateBounds(tv, sv, newTv));	1✔
102	return newTv;	1✔
103	}
104
105	private static SubstVar updateBounds(JTypeVar tv, SubstVar sv, CapturedTypeVar newTv) {
106	if (sv == tv) {	1!
NEW 107	return newTv;	×
108	} else if (sv instanceof JTypeVar) {	1!
109	return ((JTypeVar) sv).substInBounds(sv2 -> {	1✔
110	if (sv2 == tv) {	1✔
111	return newTv;	1✔
112	}
113	return sv2;	1✔
114	});
115	}
NEW 116	return sv;	×
117	}
118
119	static final class RegularTypeVar extends TypeVarImpl {
120
121	private final @NonNull JTypeParameterSymbol symbol;
122
123	RegularTypeVar(TypeSystem ts, @NonNull JTypeParameterSymbol symbol, PSet<SymAnnot> typeAnnots) {
124	super(ts, typeAnnots);	1✔
125	this.symbol = symbol;	1✔
126	}	1✔
127
128	private RegularTypeVar(RegularTypeVar base, PSet<SymAnnot> typeAnnots) {
129	this(base.ts, base.symbol, typeAnnots);	1✔
130	this.upperBound = base.upperBound;	1✔
131	}	1✔
132
133	@Override
134	public boolean isCaptured() {
135	return false;	1✔
136	}
137
138	@Override
139	public @NonNull JTypeMirror getLowerBound() {
140	return ts.NULL_TYPE;	1✔
141	}
142
143	@Override
144	public @NonNull JTypeParameterSymbol getSymbol() {
145	return symbol;	1✔
146	}
147
148	@Override
149	public @NonNull String getName() {
150	return symbol.getSimpleName();	1✔
151	}
152
153	@Override
154	public @NonNull JTypeMirror getUpperBound() {
155	if (upperBound == null) {	1✔
156	upperBound = symbol.computeUpperBound();	1✔
157	}
158	return upperBound;	1✔
159	}
160
161	@Override
162	public JTypeVar withUpperBound(@NonNull JTypeMirror newUB) {
163	RegularTypeVar tv = new RegularTypeVar(this, this.typeAnnots);	1✔
164	tv.upperBound = newUB;	1✔
165	return tv;	1✔
166	}
167
168
169	@Override
170	public JTypeVar withAnnotations(PSet<SymAnnot> newTypeAnnots) {
171	if (newTypeAnnots.isEmpty() && this.typeAnnots.isEmpty()) {	1!
172	return this;	1✔
173	}
174	return new RegularTypeVar(this, newTypeAnnots);	1✔
175	}
176
177	@Override
178	public JTypeVar substInBounds(Function<? super SubstVar, ? extends @NonNull JTypeMirror> substitution) {
179	if (Substitution.isEmptySubst(substitution)) {	1!
180	return this;	×
181	}
182	JTypeMirror newBound = getUpperBound().subst(substitution);	1✔
183	if (newBound == upperBound) {	1✔
184	return this;	1✔
185	}
186	RegularTypeVar newTVar = new RegularTypeVar(this.ts, this.symbol, this.getTypeAnnotations());	1✔
187	newTVar.upperBound = newBound;	1✔
188	return newTVar;	1✔
189	}
190
191	@Override
192	public JTypeVar cloneWithBounds(JTypeMirror lower, JTypeMirror upper) {
193	throw new UnsupportedOperationException("Not a capture variable");	×
194	}
195
196	@Override
197	public boolean isCaptureOf(JWildcardType wildcard) {
198	return false;	1✔
199	}
200
201	@Override
202	public @Nullable JWildcardType getCapturedOrigin() {
203	return null;	×
204	}
205
206	// we only compare the symbol
207	// the point is to make tvars whose bound was substed equal to the original
208	// tvar, for substs to work repeatedly. Maybe improving how JMethodSig works
209	// would remove the need for that
210	// Eg it would be nice to conceptualize JMethodSig as just a method symbol +
211	// a substitution mapping type params in scope at that point to actual types
212	// The problem is that we may want to subst it with type vars, and then use
213	// those
214
215	@Override
216	public boolean equals(Object o) {
217	if (this == o) {	1✔
218	return true;	1✔
219	}
220	if (o == null \|\| getClass() != o.getClass()) {	1!
221	return false;	1✔
222	}
223	RegularTypeVar that = (RegularTypeVar) o;	1✔
224	return symbol.equals(that.symbol);	1✔
225	}
226
227	@Override
228	public int hashCode() {
229	return symbol.hashCode();	1✔
230	}
231	}
232
233	static final class CapturedTypeVar extends TypeVarImpl {
234
235	private static final int PRIME = 997; // largest prime less than 1000
236
237	private final @Nullable JWildcardType wildcard;
238	private final @Nullable JTypeVar tvar;
239
240	private JTypeMirror upperBound;
241	private JTypeMirror lowerBound;
242
243	private CapturedTypeVar(@NonNull JWildcardType wild, PSet<SymAnnot> typeAnnots) {
244	this(wild, wild.asLowerBound(), wild.asUpperBound(), typeAnnots);	1✔
245	}	1✔
246
247	private CapturedTypeVar(@Nullable JWildcardType wild, @NonNull JTypeMirror lower, @NonNull JTypeMirror upper, PSet<SymAnnot> typeAnnots) {
248	super(lower.getTypeSystem(), typeAnnots);	1✔
249	this.upperBound = upper;	1✔
250	this.lowerBound = lower;	1✔
251	this.wildcard = wild;	1✔
252	this.tvar = null;	1✔
253	}	1✔
254
255	private CapturedTypeVar(@Nullable JTypeVar tvar, @NonNull JTypeMirror lower, @NonNull JTypeMirror upper, PSet<SymAnnot> typeAnnots) {
256	super(lower.getTypeSystem(), typeAnnots);	1✔
257	this.upperBound = upper;	1✔
258	this.lowerBound = lower;	1✔
259	this.tvar = tvar;	1✔
260	this.wildcard = null;	1✔
261	}	1✔
262
263	private CapturedTypeVar(@Nullable JTypeVar tvar, JWildcardType wild, @NonNull JTypeMirror lower, @NonNull JTypeMirror upper, PSet<SymAnnot> typeAnnots) {
NEW 264	super(lower.getTypeSystem(), typeAnnots);	×
NEW 265	this.upperBound = upper;	×
NEW 266	this.lowerBound = lower;	×
NEW 267	this.tvar = tvar;	×
NEW 268	this.wildcard = wild;	×
UNCOV 269	}	×
270
271	void setUpperBound(@NonNull JTypeMirror upperBound) {
272	this.upperBound = upperBound;	1✔
273	}	1✔
274
275
276	void setLowerBound(@NonNull JTypeMirror lowerBound) {
277	this.lowerBound = lowerBound;	1✔
278	}	1✔
279
280	@Override
281	public boolean equals(Object o) {
282	return this == o \|\| o instanceof CaptureMatcher && o.equals(this);	1✔
283	}
284
285	@Override
286	public int hashCode() { // NOPMD UselessOverridingMethod
287	return super.hashCode();	1✔
288	}
289
290	@Override
291	public boolean isCaptured() {
292	return true;	1✔
293	}
294
295	@Override
296	public boolean isCaptureOf(JWildcardType wildcard) {
297	return this.wildcard != null && this.wildcard.equals(wildcard);	1!
298	}
299
300	@Override
301	public JWildcardType getCapturedOrigin() {
302	return wildcard;	1✔
303	}
304
305	@Override
306	public JTypeVar substInBounds(Function<? super SubstVar, ? extends @NonNull JTypeMirror> substitution) {
307	JWildcardType wild = this.wildcard == null ? null : this.wildcard.subst(substitution);	1!
308	JTypeMirror lower = getLowerBound().subst(substitution);	1✔
309	JTypeMirror upper = getUpperBound().subst(substitution);	1✔
310	if (wild == this.wildcard && lower == this.lowerBound && upper == this.lowerBound) {	1!
311	return this;	×
312	} else if (wild == null) {	1!
NEW 313	return new CapturedTypeVar(tvar, lower, upper, typeAnnots);	×
314	}
315	return new CapturedTypeVar(wild, lower, upper, getTypeAnnotations());	1✔
316	}
317
318	@Override
319	public JTypeVar cloneWithBounds(JTypeMirror lower, JTypeMirror upper) {
320	return new CapturedTypeVar(wildcard, lower, upper, getTypeAnnotations());	1✔
321	}
322
323
324	@Override
325	public JTypeVar withAnnotations(PSet<SymAnnot> newTypeAnnots) {
326	if (newTypeAnnots.isEmpty() && typeAnnots.isEmpty()) {	×
327	return this;	×
328	}
NEW 329	return new CapturedTypeVar(tvar, wildcard, lowerBound, upperBound, newTypeAnnots);	×
330	}
331
332	@Override
333	public JTypeVar withUpperBound(@NonNull JTypeMirror newUB) {
NEW 334	throw new UnsupportedOperationException("This only needs to be implemented on regular type variables");	×
335	}
336
337	@Override
338	public @NonNull JTypeMirror getUpperBound() {
339	return upperBound;	1✔
340	}
341
342	@Override
343	public @NonNull JTypeMirror getLowerBound() {
344	return lowerBound;	1✔
345	}
346
347	@Override
348	public @Nullable JTypeParameterSymbol getSymbol() {
349	return tvar == null ? null : tvar.getSymbol();	1✔
350	}
351
352	@Override
353	public @NonNull String getName() {
354	Object captureOrigin = wildcard == null ? tvar : wildcard;	1!
355	return "capture#" + hashCode() % PRIME + " of " + captureOrigin;	1✔
356	}
357	}
358	}

pmd / pmd / 4268

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