jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/code/Type.java

-:bf020de5a6db
+:831467c4c6a7
 *  This code and its internal interfaces are subject to change or
 *  deletion without notice.</b>
 *
 *  @see TypeTag
 */
-public class Type implements PrimitiveType {
+public abstract class Type implements TypeMirror {
 /** Constant type: no type at all. */
-public static final JCNoType noType = new JCNoType(NONE);
+public static final JCNoType noType = new JCNoType();
 /** Constant type: special type to be used during recovery of deferred expressions. */
-public static final JCNoType recoveryType = new JCNoType(NONE);
+public static final JCNoType recoveryType = new JCNoType();
 /** If this switch is turned on, the names of type variables
 *  and anonymous classes are printed with hashcodes appended.
 */
 public static boolean moreInfo = false;
-/** The tag of this type.
-*
-*  @see TypeTag
-*/
-protected TypeTag tag;
 /** The defining class / interface / package / type variable.
 */
 public TypeSymbol tsym;
 /**
 * Checks if the current type tag is equal to the given tag.
 * @return true if tag is equal to the current type tag.
 */
 public boolean hasTag(TypeTag tag) {
-return this.tag == tag;
+return tag == getTag();
 }
 /**
 * Returns the current type tag.
 * @return the value of the current type tag.
 */
-public TypeTag getTag() {
+public abstract TypeTag getTag();
-return tag;
-}
 public boolean isNumeric() {
-return tag.isNumeric;
+return false;
 }
 public boolean isPrimitive() {
-return tag.isPrimitive;
+return false;
 }
 public boolean isPrimitiveOrVoid() {
-return tag.isPrimitiveOrVoid;
+return false;
 }
 public boolean isReference() {
-return tag.isReference;
+return false;
 }
 public boolean isNullOrReference() {
-return (tag.isReference || tag == BOT);
+return false;
 }
 public boolean isPartial() {
-return tag.isPartial;
+return false;
 }
 /**
 * The constant value of this type, null if this type does not
 * have a constant value attribute. Only primitive types and
 */
 public Object constValue() {
 return null;
 }
+/** Is this a constant type whose value is false?
+*/
+public boolean isFalse() {
+return false;
+}
+/** Is this a constant type whose value is true?
+*/
+public boolean isTrue() {
+return false;
+}
 /**
 * Get the representation of this type used for modelling purposes.
 * By default, this is itself. For ErrorType, a different value
 * may be provided.
 */
 public Type getModelType() {
 return this;
 }
 public static List<Type> getModelTypes(List<Type> ts) {
-ListBuffer<Type> lb = new ListBuffer<Type>();
+ListBuffer<Type> lb = new ListBuffer<>();
 for (Type t: ts)
 lb.append(t.getModelType());
 return lb.toList();
 }
 public <R,S> R accept(Type.Visitor<R,S> v, S s) { return v.visitType(this, s); }
 /** Define a type given its tag and type symbol
 */
-public Type(TypeTag tag, TypeSymbol tsym) {
+public Type(TypeSymbol tsym) {
-this.tag = tag;
 this.tsym = tsym;
 }
 /** An abstract class for mappings from types to types
 */
 /** Define a constant type, of the same kind as this type
 *  and with given constant value
 */
 public Type constType(Object constValue) {
-final Object value = constValue;
+throw new AssertionError();
-Assert.check(isPrimitive());
-return new Type(tag, tsym) {
-@Override
-public Object constValue() {
-return value;
-}
-@Override
-public Type baseType() {
-return tsym.type;
-}
-};
 }
 /**
 * If this is a constant type, return its underlying type.
 * Otherwise, return the type itself.
 */
 public String toString() {
 String s = (tsym == null || tsym.name == null)
 ? "<none>"
 : tsym.name.toString();
-if (moreInfo && tag == TYPEVAR) s = s + hashCode();
+if (moreInfo && hasTag(TYPEVAR)) {
+s = s + hashCode();
+}
 return s;
 }
 /**
 * The Java source which this type list represents.  A List is
 /**
 * The constant value of this type, converted to String
 */
 public String stringValue() {
 Object cv = Assert.checkNonNull(constValue());
-if (tag == BOOLEAN)
+return cv.toString();
-return ((Integer) cv).intValue() == 0 ? "false" : "true";
-else if (tag == CHAR)
-return String.valueOf((char) ((Integer) cv).intValue());
-else
-return cv.toString();
 }
 /**
 * This method is analogous to isSameType, but weaker, since we
 * never complete classes. Where isSameType would complete a
 }
 @Override
 public int hashCode() {
 return super.hashCode();
-}
-/** Is this a constant type whose value is false?
-*/
-public boolean isFalse() {
-return
-tag == BOOLEAN &&
-constValue() != null &&
-((Integer)constValue()).intValue() == 0;
-}
-/** Is this a constant type whose value is true?
-*/
-public boolean isTrue() {
-return
-tag == BOOLEAN &&
-constValue() != null &&
-((Integer)constValue()).intValue() != 0;
 }
 public String argtypes(boolean varargs) {
 List<Type> args = getParameterTypes();
 if (!varargs) return args.toString();
 while (args.tail.nonEmpty()) {
 buf.append(args.head);
 args = args.tail;
 buf.append(',');
 }
-if (args.head.unannotatedType().tag == ARRAY) {
+if (args.head.unannotatedType().hasTag(ARRAY)) {
 buf.append(((ArrayType)args.head.unannotatedType()).elemtype);
 if (args.head.getAnnotationMirrors().nonEmpty()) {
 buf.append(args.head.getAnnotationMirrors());
 }
 buf.append("...");
 public TypeSymbol asElement() {
 return tsym;
 }
+@Override
 public TypeKind getKind() {
-switch (tag) {
+return TypeKind.OTHER;
-case BYTE:      return TypeKind.BYTE;
+}
-case CHAR:      return TypeKind.CHAR;
-case SHORT:     return TypeKind.SHORT;
+@Override
-case INT:       return TypeKind.INT;
-case LONG:      return TypeKind.LONG;
-case FLOAT:     return TypeKind.FLOAT;
-case DOUBLE:    return TypeKind.DOUBLE;
-case BOOLEAN:   return TypeKind.BOOLEAN;
-case VOID:      return TypeKind.VOID;
-case BOT:       return TypeKind.NULL;
-case NONE:      return TypeKind.NONE;
-default:        return TypeKind.OTHER;
-}
-}
 public <R, P> R accept(TypeVisitor<R, P> v, P p) {
-if (isPrimitive())
+throw new AssertionError();
+}
+public static class JCPrimitiveType extends Type
+implements javax.lang.model.type.PrimitiveType {
+TypeTag tag;
+public JCPrimitiveType(TypeTag tag, TypeSymbol tsym) {
+super(tsym);
+this.tag = tag;
+Assert.check(tag.isPrimitive);
+}
+@Override
+public boolean isNumeric() {
+return tag != BOOLEAN;
+}
+@Override
+public boolean isPrimitive() {
+return true;
+}
+@Override
+public TypeTag getTag() {
+return tag;
+}
+@Override
+public boolean isPrimitiveOrVoid() {
+return true;
+}
+/** Define a constant type, of the same kind as this type
+*  and with given constant value
+*/
+@Override
+public Type constType(Object constValue) {
+final Object value = constValue;
+return new JCPrimitiveType(tag, tsym) {
+@Override
+public Object constValue() {
+return value;
+}
+@Override
+public Type baseType() {
+return tsym.type;
+}
+};
+}
+/**
+* The constant value of this type, converted to String
+*/
+@Override
+public String stringValue() {
+Object cv = Assert.checkNonNull(constValue());
+if (tag == BOOLEAN) {
+return ((Integer) cv).intValue() == 0 ? "false" : "true";
+}
+else if (tag == CHAR) {
+return String.valueOf((char) ((Integer) cv).intValue());
+}
+else {
+return cv.toString();
+}
+}
+/** Is this a constant type whose value is false?
+*/
+@Override
+public boolean isFalse() {
+return
+tag == BOOLEAN &&
+constValue() != null &&
+((Integer)constValue()).intValue() == 0;
+}
+/** Is this a constant type whose value is true?
+*/
+@Override
+public boolean isTrue() {
+return
+tag == BOOLEAN &&
+constValue() != null &&
+((Integer)constValue()).intValue() != 0;
+}
+@Override
+public <R, P> R accept(TypeVisitor<R, P> v, P p) {
 return v.visitPrimitive(this, p);
-else
+}
+@Override
+public TypeKind getKind() {
+switch (tag) {
+case BYTE:      return TypeKind.BYTE;
+case CHAR:      return TypeKind.CHAR;
+case SHORT:     return TypeKind.SHORT;
+case INT:       return TypeKind.INT;
+case LONG:      return TypeKind.LONG;
+case FLOAT:     return TypeKind.FLOAT;
+case DOUBLE:    return TypeKind.DOUBLE;
+case BOOLEAN:   return TypeKind.BOOLEAN;
+}
 throw new AssertionError();
+}
 }
 public static class WildcardType extends Type
 implements javax.lang.model.type.WildcardType {
 public <R,S> R accept(Type.Visitor<R,S> v, S s) {
 return v.visitWildcardType(this, s);
 }
 public WildcardType(Type type, BoundKind kind, TypeSymbol tsym) {
-super(WILDCARD, tsym);
+super(tsym);
 this.type = Assert.checkNonNull(type);
 this.kind = kind;
 }
 public WildcardType(WildcardType t, TypeVar bound) {
 this(t.type, t.kind, t.tsym, bound);
 public WildcardType(Type type, BoundKind kind, TypeSymbol tsym, TypeVar bound) {
 this(type, kind, tsym);
 this.bound = bound;
 }
+@Override
+public TypeTag getTag() {
+return WILDCARD;
+}
+@Override
 public boolean contains(Type t) {
 return kind != UNBOUND && type.contains(t);
 }
 public boolean isSuperBound() {
 }
 public boolean isUnbound() {
 return kind == UNBOUND;
 }
+@Override
+public boolean isReference() {
+return true;
+}
+@Override
+public boolean isNullOrReference() {
+return true;
+}
+@Override
 public Type withTypeVar(Type t) {
 //-System.err.println(this+".withTypeVar("+t+");");//DEBUG
 if (bound == t)
 return this;
 bound = (TypeVar)t;
 /** All the interfaces of this class, including missing ones.
 */
 public List<Type> all_interfaces_field;
 public ClassType(Type outer, List<Type> typarams, TypeSymbol tsym) {
-super(CLASS, tsym);
+super(tsym);
 this.outer_field = outer;
 this.typarams_field = typarams;
 this.allparams_field = null;
 this.supertype_field = null;
 this.interfaces_field = null;
 true;
 */
 }
 @Override
+public TypeTag getTag() {
+return CLASS;
+}
+@Override
 public <R,S> R accept(Type.Visitor<R,S> v, S s) {
 return v.visitClassType(this, s);
 }
 public Type constType(Object constValue) {
 /** The Java source which this type represents.
 */
 public String toString() {
 StringBuilder buf = new StringBuilder();
-if (getEnclosingType().tag == CLASS && tsym.owner.kind == TYP) {
+if (getEnclosingType().hasTag(CLASS) && tsym.owner.kind == TYP) {
 buf.append(getEnclosingType().toString());
 buf.append(".");
 buf.append(className(tsym, false));
 } else {
 buf.append(className(tsym, true));
 public boolean isParameterized() {
 return allparams().tail != null;
 // optimization, was: allparams().nonEmpty();
 }
+@Override
+public boolean isReference() {
+return true;
+}
+@Override
+public boolean isNullOrReference() {
+return true;
+}
 /** A cache for the rank. */
 int rank_field = -1;
 /** A class type is raw if it misses some
 *  of its type parameter sections.
 implements javax.lang.model.type.ArrayType {
 public Type elemtype;
 public ArrayType(Type elemtype, TypeSymbol arrayClass) {
-super(ARRAY, arrayClass);
+super(arrayClass);
 this.elemtype = elemtype;
 }
 @Override
+public TypeTag getTag() {
+return ARRAY;
+}
 public <R,S> R accept(Type.Visitor<R,S> v, S s) {
 return v.visitArrayType(this, s);
 }
 public String toString() {
 return elemtype.isErroneous();
 }
 public boolean isParameterized() {
 return elemtype.isParameterized();
+}
+@Override
+public boolean isReference() {
+return true;
+}
+@Override
+public boolean isNullOrReference() {
+return true;
 }
 public boolean isRaw() {
 return elemtype.isRaw();
 }
 public MethodType(List<Type> argtypes,
 Type restype,
 List<Type> thrown,
 TypeSymbol methodClass) {
-super(METHOD, methodClass);
+super(methodClass);
 this.argtypes = argtypes;
 this.restype = restype;
 this.thrown = thrown;
 }
 @Override
+public TypeTag getTag() {
+return METHOD;
+}
 public <R,S> R accept(Type.Visitor<R,S> v, S s) {
 return v.visitMethodType(this, s);
 }
 /** The Java source which this type represents.
 }
 public static class PackageType extends Type implements NoType {
 PackageType(TypeSymbol tsym) {
-super(PACKAGE, tsym);
+super(tsym);
+}
+@Override
+public TypeTag getTag() {
+return PACKAGE;
 }
 @Override
 public <R,S> R accept(Type.Visitor<R,S> v, S s) {
 return v.visitPackageType(this, s);
 *  Subtypes, such as CapturedType, may provide a different value.
 */
 public Type lower;
 public TypeVar(Name name, Symbol owner, Type lower) {
-super(TYPEVAR, null);
+super(null);
 tsym = new TypeVariableSymbol(0, name, this, owner);
 this.lower = lower;
 }
 public TypeVar(TypeSymbol tsym, Type bound, Type lower) {
-super(TYPEVAR, tsym);
+super(tsym);
 this.bound = bound;
 this.lower = lower;
 }
 @Override
+public TypeTag getTag() {
+return TYPEVAR;
+}
+@Override
 public <R,S> R accept(Type.Visitor<R,S> v, S s) {
 return v.visitTypeVar(this, s);
 }
 @Override
 public Type getUpperBound() {
-if ((bound == null || bound.tag == NONE) && this != tsym.type)
+if ((bound == null || bound.hasTag(NONE)) && this != tsym.type) {
 bound = tsym.type.getUpperBound();
+}
 return bound;
 }
 int rank_field = -1;
 public boolean isCaptured() {
 return false;
 }
+@Override
+public boolean isReference() {
+return true;
+}
+@Override
+public boolean isNullOrReference() {
+return true;
+}
+@Override
 public <R, P> R accept(TypeVisitor<R, P> v, P p) {
 return v.visitTypeVariable(this, p);
 }
 }
 }
 }
 public static abstract class DelegatedType extends Type {
 public Type qtype;
+public TypeTag tag;
 public DelegatedType(TypeTag tag, Type qtype) {
-super(tag, qtype.tsym);
+super(qtype.tsym);
+this.tag = tag;
 this.qtype = qtype;
 }
+public TypeTag getTag() { return tag; }
 public String toString() { return qtype.toString(); }
 public List<Type> getTypeArguments() { return qtype.getTypeArguments(); }
 public Type getEnclosingType() { return qtype.getEnclosingType(); }
 public List<Type> getParameterTypes() { return qtype.getParameterTypes(); }
 public Type getReturnType() { return qtype.getReturnType(); }
 public String toString() {
 if (inst != null) return inst.toString();
 else return qtype + "?";
 }
+@Override
+public boolean isPartial() {
+return true;
+}
+@Override
 public Type baseType() {
 if (inst != null) return inst.baseType();
 else return this;
 }
 listener.varChanged(this, ibs);
 }
 }
 }
-/** Represents VOID or NONE.
+/** Represents NONE.
 */
-static class JCNoType extends Type implements NoType {
+public static class JCNoType extends Type implements NoType {
-public JCNoType(TypeTag tag) {
+public JCNoType() {
-super(tag, null);
+super(null);
+}
+@Override
+public TypeTag getTag() {
+return NONE;
 }
 @Override
 public TypeKind getKind() {
-switch (tag) {
+return TypeKind.NONE;
-case VOID:  return TypeKind.VOID;
-case NONE:  return TypeKind.NONE;
-default:
-throw new AssertionError("Unexpected tag: " + tag);
-}
 }
 @Override
 public <R, P> R accept(TypeVisitor<R, P> v, P p) {
 return v.visitNoType(this, p);
 }
 }
+/** Represents VOID.
+*/
+public static class JCVoidType extends Type implements NoType {
+public JCVoidType() {
+super(null);
+}
+@Override
+public TypeTag getTag() {
+return VOID;
+}
+@Override
+public TypeKind getKind() {
+return TypeKind.VOID;
+}
+@Override
+public <R, P> R accept(TypeVisitor<R, P> v, P p) {
+return v.visitNoType(this, p);
+}
+@Override
+public boolean isPrimitiveOrVoid() {
+return true;
+}
+}
 static class BottomType extends Type implements NullType {
 public BottomType() {
-super(BOT, null);
+super(null);
+}
+@Override
+public TypeTag getTag() {
+return BOT;
 }
 @Override
 public TypeKind getKind() {
 return TypeKind.NULL;
 @Override
 public String stringValue() {
 return "null";
 }
+@Override
+public boolean isNullOrReference() {
+return true;
+}
 }
 public static class ErrorType extends ClassType
 implements javax.lang.model.type.ErrorType {
 private Type originalType = null;
 public ErrorType(Type originalType, TypeSymbol tsym) {
 super(noType, List.<Type>nil(), null);
-tag = ERROR;
 this.tsym = tsym;
 this.originalType = (originalType == null ? noType : originalType);
 }
 public ErrorType(ClassSymbol c, Type originalType) {
 this(originalType, c);
 c.type = this;
 c.kind = ERR;
 c.members_field = new Scope.ErrorScope(c);
+}
+@Override
+public TypeTag getTag() {
+return ERROR;
+}
+@Override
+public boolean isPartial() {
+return true;
+}
+@Override
+public boolean isReference() {
+return true;
+}
+@Override
+public boolean isNullOrReference() {
+return true;
 }
 public ErrorType(Name name, TypeSymbol container, Type originalType) {
 this(new ClassSymbol(PUBLIC|STATIC|ACYCLIC, name, null, container), originalType);
 }
 /** The underlying type that is annotated.
 */
 public Type underlyingType;
 public AnnotatedType(Type underlyingType) {
-super(underlyingType.tag, underlyingType.tsym);
+super(underlyingType.tsym);
 this.typeAnnotations = List.nil();
 this.underlyingType = underlyingType;
 Assert.check(!underlyingType.isAnnotated(),
 "Can't annotate already annotated type: " + underlyingType);
 }
 public AnnotatedType(List<Attribute.TypeCompound> typeAnnotations,
 Type underlyingType) {
-super(underlyingType.tag, underlyingType.tsym);
+super(underlyingType.tsym);
 this.typeAnnotations = typeAnnotations;
 this.underlyingType = underlyingType;
 Assert.check(!underlyingType.isAnnotated(),
 "Can't annotate already annotated type: " + underlyingType +
 "; adding: " + typeAnnotations);
 }
 @Override
+public TypeTag getTag() {
+return underlyingType.getTag();
+}
+@Override
 public boolean isAnnotated() {
 return true;
 }
 @Override
 @Override
 public boolean isInterface()             { return underlyingType.isInterface(); }
 @Override
 public List<Type> allparams()            { return underlyingType.allparams(); }
 @Override
+public boolean isPrimitive()             { return underlyingType.isPrimitive(); }
+@Override
+public boolean isPrimitiveOrVoid()       { return underlyingType.isPrimitiveOrVoid(); }
+@Override
 public boolean isNumeric()               { return underlyingType.isNumeric(); }
 @Override
 public boolean isReference()             { return underlyingType.isReference(); }
+@Override
+public boolean isNullOrReference()       { return underlyingType.isNullOrReference(); }
+@Override
+public boolean isPartial()               { return underlyingType.isPartial(); }
 @Override
 public boolean isParameterized()         { return underlyingType.isParameterized(); }
 @Override
 public boolean isRaw()                   { return underlyingType.isRaw(); }
 @Override
 @Override
 public TypeMirror getExtendsBound()      { return ((WildcardType)underlyingType).getExtendsBound(); }
 @Override
 public TypeMirror getSuperBound()        { return ((WildcardType)underlyingType).getSuperBound(); }
+}
+public static class UnknownType extends Type {
+public UnknownType() {
+super(null);
+}
+@Override
+public TypeTag getTag() {
+return UNKNOWN;
+}
+@Override
+public <R, P> R accept(TypeVisitor<R, P> v, P p) {
+return v.visitUnknown(this, p);
+}
+@Override
+public boolean isPartial() {
+return true;
+}
 }
 /**
 * A visitor for types.  A visitor is used to implement operations
 * (or relations) on types.  Most common operations on types are

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/code/Type.java

src/share/classes/com/sun/tools/javac/code/Type.java