# HG changeset patch # User mcimadamore # Date 1516814672 0 # Node ID 19173eb3358b99eda2a3df9603dcd95e6fb1bf48 # Parent 693052e16ac9d50fd0fac97f1ece095793a8d31a 8196074: Remove uses of loose type equality tests Summary: Drop loose type equality check and replace usages to go throuhg the strict version Reviewed-by: vromero Contributed-by: bsrbnd@gmail.com diff -r 693052e16ac9 -r 19173eb3358b src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java Wed Jan 24 14:07:11 2018 +0530 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java Wed Jan 24 17:24:32 2018 +0000 @@ -2107,9 +2107,8 @@ List prevBounds = bounds.get(ib); if (bound == qtype) return; for (Type b : prevBounds) { - //check for redundancy - use strict version of isSameType on tvars - //(as the standard version will lead to false positives w.r.t. clones ivars) - if (types.isSameType(b, bound2, true)) return; + //check for redundancy - do not add same bound twice + if (types.isSameType(b, bound2)) return; } bounds.put(ib, prevBounds.prepend(bound2)); notifyBoundChange(ib, bound2, false); diff -r 693052e16ac9 -r 19173eb3358b src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java Wed Jan 24 14:07:11 2018 +0530 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java Wed Jan 24 17:24:32 2018 +0000 @@ -1291,12 +1291,9 @@ * lists are of different length, return false. */ public boolean isSameTypes(List ts, List ss) { - return isSameTypes(ts, ss, false); - } - public boolean isSameTypes(List ts, List ss, boolean strict) { while (ts.tail != null && ss.tail != null /*inlined: ts.nonEmpty() && ss.nonEmpty()*/ && - isSameType(ts.head, ss.head, strict)) { + isSameType(ts.head, ss.head)) { ts = ts.tail; ss = ss.tail; } @@ -1325,15 +1322,15 @@ * Is t the same type as s? */ public boolean isSameType(Type t, Type s) { - return isSameType(t, s, false); - } - public boolean isSameType(Type t, Type s, boolean strict) { - return strict ? - isSameTypeStrict.visit(t, s) : - isSameTypeLoose.visit(t, s); + return isSameTypeVisitor.visit(t, s); } // where - abstract class SameTypeVisitor extends TypeRelation { + + /** + * Type-equality relation - type variables are considered + * equals if they share the same object identity. + */ + TypeRelation isSameTypeVisitor = new TypeRelation() { public Boolean visitType(Type t, Type s) { if (t.equalsIgnoreMetadata(s)) @@ -1350,7 +1347,7 @@ if (s.hasTag(TYPEVAR)) { //type-substitution does not preserve type-var types //check that type var symbols and bounds are indeed the same - return sameTypeVars((TypeVar)t, (TypeVar)s); + return t == s; } else { //special case for s == ? super X, where upper(s) = u @@ -1365,8 +1362,6 @@ } } - abstract boolean sameTypeVars(TypeVar tv1, TypeVar tv2); - @Override public Boolean visitWildcardType(WildcardType t, Type s) { if (!s.hasTag(WILDCARD)) { @@ -1374,7 +1369,7 @@ } else { WildcardType t2 = (WildcardType)s; return (t.kind == t2.kind || (t.isExtendsBound() && s.isExtendsBound())) && - isSameType(t.type, t2.type, true); + isSameType(t.type, t2.type); } } @@ -1411,10 +1406,8 @@ } return t.tsym == s.tsym && visit(t.getEnclosingType(), s.getEnclosingType()) - && containsTypes(t.getTypeArguments(), s.getTypeArguments()); - } - - abstract protected boolean containsTypes(List ts1, List ts2); + && containsTypeEquivalent(t.getTypeArguments(), s.getTypeArguments()); + } @Override public Boolean visitArrayType(ArrayType t, Type s) { @@ -1471,70 +1464,6 @@ public Boolean visitErrorType(ErrorType t, Type s) { return true; } - } - - /** - * Standard type-equality relation - type variables are considered - * equals if they share the same type symbol. - */ - TypeRelation isSameTypeLoose = new LooseSameTypeVisitor(); - - private class LooseSameTypeVisitor extends SameTypeVisitor { - - /** cache of the type-variable pairs being (recursively) tested. */ - private Set cache = new HashSet<>(); - - @Override - boolean sameTypeVars(TypeVar tv1, TypeVar tv2) { - return tv1.tsym == tv2.tsym && checkSameBounds(tv1, tv2); - } - @Override - protected boolean containsTypes(List ts1, List ts2) { - return containsTypeEquivalent(ts1, ts2); - } - - /** - * Since type-variable bounds can be recursive, we need to protect against - * infinite loops - where the same bounds are checked over and over recursively. - */ - private boolean checkSameBounds(TypeVar tv1, TypeVar tv2) { - TypePair p = new TypePair(tv1, tv2, true); - if (cache.add(p)) { - try { - return visit(tv1.getUpperBound(), tv2.getUpperBound()); - } finally { - cache.remove(p); - } - } else { - return false; - } - } - }; - - /** - * Strict type-equality relation - type variables are considered - * equals if they share the same object identity. - */ - TypeRelation isSameTypeStrict = new SameTypeVisitor() { - @Override - boolean sameTypeVars(TypeVar tv1, TypeVar tv2) { - return tv1 == tv2; - } - @Override - protected boolean containsTypes(List ts1, List ts2) { - return isSameTypes(ts1, ts2, true); - } - - @Override - public Boolean visitWildcardType(WildcardType t, Type s) { - if (!s.hasTag(WILDCARD)) { - return false; - } else { - WildcardType t2 = (WildcardType)s; - return t.kind == t2.kind && - isSameType(t.type, t2.type, true); - } - } }; // @@ -3848,17 +3777,11 @@ // where class TypePair { final Type t1; - final Type t2; - boolean strict; + final Type t2;; TypePair(Type t1, Type t2) { - this(t1, t2, false); - } - - TypePair(Type t1, Type t2, boolean strict) { this.t1 = t1; this.t2 = t2; - this.strict = strict; } @Override public int hashCode() { @@ -3869,8 +3792,8 @@ if (!(obj instanceof TypePair)) return false; TypePair typePair = (TypePair)obj; - return isSameType(t1, typePair.t1, strict) - && isSameType(t2, typePair.t2, strict); + return isSameType(t1, typePair.t1) + && isSameType(t2, typePair.t2); } } Set mergeCache = new HashSet<>(); @@ -4460,7 +4383,7 @@ Type tmpLower = Si.lower.hasTag(UNDETVAR) ? ((UndetVar)Si.lower).qtype : Si.lower; if (!Si.bound.hasTag(ERROR) && !Si.lower.hasTag(ERROR) && - isSameType(tmpBound, tmpLower, false)) { + isSameType(tmpBound, tmpLower)) { currentS.head = Si.bound; } } diff -r 693052e16ac9 -r 19173eb3358b src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java Wed Jan 24 14:07:11 2018 +0530 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java Wed Jan 24 17:24:32 2018 +0000 @@ -565,7 +565,7 @@ List argtypes) { final Type restype; - if (spMethod == null || types.isSameType(spMethod.getReturnType(), syms.objectType, true)) { + if (spMethod == null || types.isSameType(spMethod.getReturnType(), syms.objectType)) { // The return type of the polymorphic signature is polymorphic, // and is computed from the enclosing tree E, as follows: // if E is a cast, then use the target type of the cast expression @@ -1227,8 +1227,8 @@ } else { IncorporationBinaryOp that = (IncorporationBinaryOp)o; return opKind == that.opKind && - types.isSameType(op1, that.op1, true) && - types.isSameType(op2, that.op2, true); + types.isSameType(op1, that.op1) && + types.isSameType(op2, that.op2); } } diff -r 693052e16ac9 -r 19173eb3358b src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TransTypes.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TransTypes.java Wed Jan 24 14:07:11 2018 +0530 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TransTypes.java Wed Jan 24 17:24:32 2018 +0000 @@ -788,7 +788,7 @@ JCTypeCast typeCast = newExpression.hasTag(Tag.TYPECAST) ? (JCTypeCast) newExpression : null; - tree.expr = typeCast != null && types.isSameType(typeCast.type, originalTarget, true) + tree.expr = typeCast != null && types.isSameType(typeCast.type, originalTarget) ? typeCast.expr : newExpression; }