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

-:4a1c57a1c410
+:c002fdee76fd
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.Name;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Kinds.*;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
+import static com.sun.tools.javac.code.TypeTag.FORALL;
+import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
 /** Root class for Java symbols. It contains subclasses
 *  for specific sorts of symbols, such as variables, methods and operators,
 *  types, packages. Each subclass is represented as a static inner class
 *  inside Symbol.
 public Symbol location(Type site, Types types) {
 if (owner.name == null || owner.name.isEmpty()) {
 return location();
 }
-if (owner.type.tag == CLASS) {
+if (owner.type.hasTag(CLASS)) {
 Type ownertype = types.asOuterSuper(site, owner);
 if (ownertype != null) return ownertype.tsym;
 }
 return owner;
 }
 }
 /** A class is an inner class if it it has an enclosing instance class.
 */
 public boolean isInner() {
-return type.getEnclosingType().tag == CLASS;
+return type.getEnclosingType().hasTag(CLASS);
 }
 /** An inner class has an outer instance if it is not an interface
 *  it has an enclosing instance class which might be referenced from the class.
 *  Nested classes can see instance members of their enclosing class.
 *
 *  @see #isInner
 */
 public boolean hasOuterInstance() {
 return
-type.getEnclosingType().tag == CLASS && (flags() & (INTERFACE | NOOUTERTHIS)) == 0;
+type.getEnclosingType().hasTag(CLASS) && (flags() & (INTERFACE | NOOUTERTHIS)) == 0;
 }
 /** The closest enclosing class of this symbol's declaration.
 */
 public ClassSymbol enclClass() {
 Symbol c = this;
 while (c != null &&
-((c.kind & TYP) == 0 || c.type.tag != CLASS)) {
+((c.kind & TYP) == 0 || !c.type.hasTag(CLASS))) {
 c = c.owner;
 }
 return (ClassSymbol)c;
 }
 types.isSubSignature(e.sym.type, type)))
 return true;
 e = e.next();
 }
 Type superType = types.supertype(clazz.type);
-if (superType.tag != TypeTags.CLASS) return false;
+if (!superType.hasTag(CLASS)) return false;
 clazz = (ClassSymbol)superType.tsym;
 }
 }
 /** Is this symbol inherited into a given class?
 case 0:
 PackageSymbol thisPackage = this.packge();
 for (Symbol sup = clazz;
 sup != null && sup != this.owner;
 sup = types.supertype(sup.type).tsym) {
-while (sup.type.tag == TYPEVAR)
+while (sup.type.hasTag(TYPEVAR))
 sup = sup.type.getUpperBound().tsym;
 if (sup.type.isErroneous())
 return true; // error recovery
 if ((sup.flags() & COMPOUND) != 0)
 continue;
 */
 static public Name formFullName(Name name, Symbol owner) {
 if (owner == null) return name;
 if (((owner.kind != ERR)) &&
 ((owner.kind & (VAR | MTH)) != 0
-|| (owner.kind == TYP && owner.type.tag == TYPEVAR)
+|| (owner.kind == TYP && owner.type.hasTag(TYPEVAR))
 )) return name;
 Name prefix = owner.getQualifiedName();
 if (prefix == null || prefix == prefix.table.names.empty)
 return name;
 else return prefix.append('.', name);
 *  converting to flat representation
 */
 static public Name formFlatName(Name name, Symbol owner) {
 if (owner == null ||
 (owner.kind & (VAR | MTH)) != 0
-|| (owner.kind == TYP && owner.type.tag == TYPEVAR)
+|| (owner.kind == TYP && owner.type.hasTag(TYPEVAR))
 ) return name;
 char sep = owner.kind == TYP ? '$' : '.';
 Name prefix = owner.flatName();
 if (prefix == null || prefix == prefix.table.names.empty)
 return name;
 */
 public final boolean precedes(TypeSymbol that, Types types) {
 if (this == that)
 return false;
 if (this.type.tag == that.type.tag) {
-if (this.type.tag == CLASS) {
+if (this.type.hasTag(CLASS)) {
 return
 types.rank(that.type) < types.rank(this.type) ||
 types.rank(that.type) == types.rank(this.type) &&
 that.getQualifiedName().compareTo(this.getQualifiedName()) < 0;
-} else if (this.type.tag == TYPEVAR) {
+} else if (this.type.hasTag(TYPEVAR)) {
 return types.isSubtype(this.type, that.type);
 }
 }
-return this.type.tag == TYPEVAR;
+return this.type.hasTag(TYPEVAR);
 }
 // For type params; overridden in subclasses.
 public ElementKind getKind() {
 return ElementKind.TYPE_PARAMETER;
 }
 public java.util.List<Symbol> getEnclosedElements() {
 List<Symbol> list = List.nil();
-if (kind == TYP && type.tag == TYPEVAR) {
+if (kind == TYP && type.hasTag(TYPEVAR)) {
 return list;
 }
 for (Scope.Entry e = members().elems; e != null; e = e.sibling) {
 if (e.sym != null && (e.sym.flags() & SYNTHETIC) == 0 && e.sym.owner == this)
 list = list.prepend(e.sym);
 public Symbol getGenericElement() {
 return owner;
 }
 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
-Assert.check(type.tag == TYPEVAR); // else override will be invoked
+Assert.check(type.hasTag(TYPEVAR)); // else override will be invoked
 return v.visitTypeParameter(this, p);
 }
 public <R, P> R accept(Symbol.Visitor<R, P> v, P p) {
 return v.visitTypeSymbol(this, p);
 public boolean isSubClass(Symbol base, Types types) {
 if (this == base) {
 return true;
 } else if ((base.flags() & INTERFACE) != 0) {
-for (Type t = type; t.tag == CLASS; t = types.supertype(t))
+for (Type t = type; t.hasTag(CLASS); t = types.supertype(t))
 for (List<Type> is = types.interfaces(t);
 is.nonEmpty();
 is = is.tail)
 if (is.head.tsym.isSubClass(base, types)) return true;
 } else {
-for (Type t = type; t.tag == CLASS; t = types.supertype(t))
+for (Type t = type; t.hasTag(CLASS); t = types.supertype(t))
 if (t.tsym == base) return true;
 }
 return false;
 }
 /** Construct a method symbol, given its flags, name, type and owner.
 */
 public MethodSymbol(long flags, Name name, Type type, Symbol owner) {
 super(MTH, flags, name, type, owner);
-if (owner.type.tag == TYPEVAR) Assert.error(owner + "." + name);
+if (owner.type.hasTag(TYPEVAR)) Assert.error(owner + "." + name);
 }
 /** Clone this symbol with new owner.
 */
 public MethodSymbol clone(Symbol newOwner) {
 } else {
 String s = (name == name.table.names.init)
 ? owner.name.toString()
 : name.toString();
 if (type != null) {
-if (type.tag == FORALL)
+if (type.hasTag(FORALL))
 s = "<" + ((ForAll)type).getTypeArguments() + ">" + s;
 s += "(" + type.argtypes((flags() & VARARGS) != 0) + ")";
 }
 return s;
 }

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

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

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