jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java

equal deleted inserted replaced

-:7115a5967ed1
+:4cba0458106b
 } else {
 return false;
 }
 }
-if (t.isCompound() || s.isCompound()) {
+if (t.isIntersection() || s.isIntersection()) {
-return !t.isCompound() ?
+return !t.isIntersection() ?
 visitIntersectionType((IntersectionClassType)s, t, true) :
 visitIntersectionType((IntersectionClassType)t, s, false);
 }
 if (s.hasTag(CLASS) || s.hasTag(ARRAY)) {
 public List<Type> erasureRecursive(List<Type> ts) {
 return Type.map(ts, erasureRecFun);
 }
 // </editor-fold>
-// <editor-fold defaultstate="collapsed" desc="makeCompoundType">
+// <editor-fold defaultstate="collapsed" desc="makeIntersectionType">
 /**
-* Make a compound type from non-empty list of types.  The list should be
+* Make an intersection type from non-empty list of types.  The list should be ordered according to
-* ordered according to {@link Symbol#precedes(TypeSymbol,Types)}.
+* {@link TypeSymbol#precedes(TypeSymbol, Types)}. Note that this might cause a symbol completion.
+* Hence, this version of makeIntersectionType may not be called during a classfile read.
 *
-* @param bounds            the types from which the compound type is formed
+* @param bounds    the types from which the intersection type is formed
-* @param supertype         is objectType if all bounds are interfaces,
+*/
-*                          null otherwise.
+public IntersectionClassType makeIntersectionType(List<Type> bounds) {
-*/
+return makeIntersectionType(bounds, bounds.head.tsym.isInterface());
-public Type makeCompoundType(List<Type> bounds) {
+}
-return makeCompoundType(bounds, bounds.head.tsym.isInterface());
-}
+/**
-public Type makeCompoundType(List<Type> bounds, boolean allInterfaces) {
+* Make an intersection type from non-empty list of types.  The list should be ordered according to
+* {@link TypeSymbol#precedes(TypeSymbol, Types)}. This does not cause symbol completion as
+* an extra parameter indicates as to whether all bounds are interfaces - in which case the
+* supertype is implicitly assumed to be 'Object'.
+*
+* @param bounds        the types from which the intersection type is formed
+* @param allInterfaces are all bounds interface types?
+*/
+public IntersectionClassType makeIntersectionType(List<Type> bounds, boolean allInterfaces) {
 Assert.check(bounds.nonEmpty());
 Type firstExplicitBound = bounds.head;
 if (allInterfaces) {
 bounds = bounds.prepend(syms.objectType);
 }
 Type.moreInfo
 ? names.fromString(bounds.toString())
 : names.empty,
 null,
 syms.noSymbol);
-bc.type = new IntersectionClassType(bounds, bc, allInterfaces);
+IntersectionClassType intersectionType = new IntersectionClassType(bounds, bc, allInterfaces);
+bc.type = intersectionType;
 bc.erasure_field = (bounds.head.hasTag(TYPEVAR)) ?
 syms.objectType : // error condition, recover
 erasure(firstExplicitBound);
 bc.members_field = WriteableScope.create(bc);
-return bc.type;
+return intersectionType;
-}
-/**
-* A convenience wrapper for {@link #makeCompoundType(List)}; the
-* arguments are converted to a list and passed to the other
-* method.  Note that this might cause a symbol completion.
-* Hence, this version of makeCompoundType may not be called
-* during a classfile read.
-*/
-public Type makeCompoundType(Type bound1, Type bound2) {
-return makeCompoundType(List.of(bound1, bound2));
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="supertype">
 public Type supertype(Type t) {
 }
 // where
 private final UnaryVisitor<List<Type>> directSupertypes = new UnaryVisitor<List<Type>>() {
 public List<Type> visitType(final Type type, final Void ignored) {
-if (!type.isCompound()) {
+if (!type.isIntersection()) {
 final Type sup = supertype(type);
 return (sup == Type.noType || sup == type || sup == null)
 ? interfaces(type)
 : interfaces(type).prepend(sup);
 } else {
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="setBounds">
 /**
-* Set the bounds field of the given type variable to reflect a
+* Same as {@link Types#setBounds(TypeVar, List, boolean)}, except that third parameter is computed directly,
-* (possibly multiple) list of bounds.
+* as follows: if all all bounds are interface types, the computed supertype is Object,otherwise
-* @param t                 a type variable
+* the supertype is simply left null (in this case, the supertype is assumed to be the head of
-* @param bounds            the bounds, must be nonempty
+* the bound list passed as second argument). Note that this check might cause a symbol completion.
-* @param supertype         is objectType if all bounds are interfaces,
+* Hence, this version of setBounds may not be called during a classfile read.
-*                          null otherwise.
+*
+* @param t         a type variable
+* @param bounds    the bounds, must be nonempty
 */
 public void setBounds(TypeVar t, List<Type> bounds) {
 setBounds(t, bounds, bounds.head.tsym.isInterface());
 }
 /**
-* Same as {@link #setBounds(Type.TypeVar,List,Type)}, except that
+* Set the bounds field of the given type variable to reflect a (possibly multiple) list of bounds.
-* third parameter is computed directly, as follows: if all
+* This does not cause symbol completion as an extra parameter indicates as to whether all bounds
-* all bounds are interface types, the computed supertype is Object,
+* are interfaces - in which case the supertype is implicitly assumed to be 'Object'.
-* otherwise the supertype is simply left null (in this case, the supertype
+*
-* is assumed to be the head of the bound list passed as second argument).
+* @param t             a type variable
-* Note that this check might cause a symbol completion. Hence, this version of
+* @param bounds        the bounds, must be nonempty
-* setBounds may not be called during a classfile read.
+* @param allInterfaces are all bounds interface types?
 */
 public void setBounds(TypeVar t, List<Type> bounds, boolean allInterfaces) {
 t.bound = bounds.tail.isEmpty() ?
 bounds.head :
-makeCompoundType(bounds, allInterfaces);
+makeIntersectionType(bounds, allInterfaces);
 t.rank_field = -1;
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="getBounds">
 Type st = subst(supertype(t));
 List<Type> is = subst(interfaces(t));
 if (st == supertype(t) && is == interfaces(t))
 return t;
 else
-return makeCompoundType(is.prepend(st));
+return makeIntersectionType(is.prepend(st));
 }
 }
 @Override
 public Type visitWildcardType(WildcardType t, Void ignored) {
 if (compound.isEmpty())
 return null;
 else if (compound.tail.isEmpty())
 return compound.head;
 else
-return makeCompoundType(compound);
+return makeIntersectionType(compound);
 }
 /**
 * Return the minimum types of a closure, suitable for computing
 * compoundMin or glb.
 // initialized lazily to avoid problems during compiler startup
 if (arraySuperType == null) {
 synchronized (this) {
 if (arraySuperType == null) {
 // JLS 10.8: all arrays implement Cloneable and Serializable.
-arraySuperType = makeCompoundType(List.of(syms.serializableType,
+arraySuperType = makeIntersectionType(List.of(syms.serializableType,
 syms.cloneableType), true);
 }
 }
 }
 return arraySuperType;
 }
 return createErrorType(errT);
 else
 return glbFlattened(union(bounds, lowers), errT);
 }
 }
-return makeCompoundType(bounds);
+return makeIntersectionType(bounds);
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="hashCode">
 /**

changeset 29147	4cba0458106b
parent 29146	7115a5967ed1
child 29292	c10d63c667cd