7200915: convert TypeTags from a series of small ints to an enum
Reviewed-by: jjg, mcimadamore
Contributed-by: vicente.romero@oracle.com
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java Thu Oct 25 11:09:36 2012 -0700
@@ -34,8 +34,6 @@
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.util.*;
-import static com.sun.tools.javac.code.TypeTags.*;
-
/** An annotation value.
*
* <p><b>This is NOT part of any supported API.
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Kinds.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Kinds.java Thu Oct 25 11:09:36 2012 -0700
@@ -32,7 +32,9 @@
import com.sun.tools.javac.api.Formattable;
import com.sun.tools.javac.api.Messages;
import static com.sun.tools.javac.code.Flags.*;
-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.PACKAGE;
+import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
/** Internal symbol kinds, which distinguish between elements of
* different subclasses of Symbol. Symbol kinds are organized so they can be
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Printer.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Printer.java Thu Oct 25 11:09:36 2012 -0700
@@ -32,9 +32,12 @@
import com.sun.tools.javac.code.Type.*;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.ListBuffer;
+
import static com.sun.tools.javac.code.BoundKind.*;
import static com.sun.tools.javac.code.Flags.*;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.ARRAY;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
+import static com.sun.tools.javac.code.TypeTag.FORALL;
/**
* A combined type/symbol visitor for generating non-trivial localized string
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Symbol.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Symbol.java Thu Oct 25 11:09:36 2012 -0700
@@ -42,7 +42,9 @@
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,
@@ -161,7 +163,7 @@
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;
}
@@ -256,7 +258,7 @@
/** 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
@@ -269,7 +271,7 @@
*/
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.
@@ -277,7 +279,7 @@
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;
@@ -346,7 +348,7 @@
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;
}
}
@@ -373,7 +375,7 @@
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
@@ -520,7 +522,7 @@
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)
@@ -534,7 +536,7 @@
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();
@@ -553,16 +555,16 @@
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.
@@ -572,7 +574,7 @@
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) {
@@ -591,7 +593,7 @@
}
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);
}
@@ -798,13 +800,13 @@
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;
@@ -1048,7 +1050,7 @@
*/
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.
@@ -1074,7 +1076,7 @@
? 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) + ")";
}
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Symtab.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Symtab.java Thu Oct 25 11:09:36 2012 -0700
@@ -37,6 +37,7 @@
import com.sun.tools.javac.util.List;
import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.jvm.ByteCodes.*;
+import static com.sun.tools.javac.code.TypeTag.*;
/** A class that defines all predefined constants and operators
* as well as special classes such as java.lang.Object, which need
@@ -64,16 +65,16 @@
/** Builtin types.
*/
- public final Type byteType = new Type(TypeTags.BYTE, null);
- public final Type charType = new Type(TypeTags.CHAR, null);
- public final Type shortType = new Type(TypeTags.SHORT, null);
- public final Type intType = new Type(TypeTags.INT, null);
- public final Type longType = new Type(TypeTags.LONG, null);
- public final Type floatType = new Type(TypeTags.FLOAT, null);
- public final Type doubleType = new Type(TypeTags.DOUBLE, null);
- public final Type booleanType = new Type(TypeTags.BOOLEAN, null);
+ public final Type byteType = new Type(BYTE, null);
+ public final Type charType = new Type(CHAR, null);
+ public final Type shortType = new Type(SHORT, null);
+ public final Type intType = new Type(INT, null);
+ public final Type longType = new Type(LONG, null);
+ public final Type floatType = new Type(FLOAT, null);
+ public final Type doubleType = new Type(DOUBLE, null);
+ public final Type booleanType = new Type(BOOLEAN, null);
public final Type botType = new BottomType();
- public final JCNoType voidType = new JCNoType(TypeTags.VOID);
+ public final JCNoType voidType = new JCNoType(VOID);
private final Names names;
private final ClassReader reader;
@@ -177,11 +178,11 @@
/** The predefined type that belongs to a tag.
*/
- public final Type[] typeOfTag = new Type[TypeTags.TypeTagCount];
+ public final Type[] typeOfTag = new Type[TypeTag.getTypeTagCount()];
/** The name of the class that belongs to a basix type tag.
*/
- public final Name[] boxedName = new Name[TypeTags.TypeTagCount];
+ public final Name[] boxedName = new Name[TypeTag.getTypeTagCount()];
/** A set containing all operator names.
*/
@@ -202,7 +203,7 @@
public void initType(Type type, ClassSymbol c) {
type.tsym = c;
- typeOfTag[type.tag] = type;
+ typeOfTag[type.tag.ordinal()] = type;
}
public void initType(Type type, String name) {
@@ -214,7 +215,7 @@
public void initType(Type type, String name, String bname) {
initType(type, name);
- boxedName[type.tag] = names.fromString("java.lang." + bname);
+ boxedName[type.tag.ordinal()] = names.fromString("java.lang." + bname);
}
/** The class symbol that owns all predefined symbols.
@@ -324,7 +325,7 @@
}
public void synthesizeBoxTypeIfMissing(final Type type) {
- ClassSymbol sym = reader.enterClass(boxedName[type.tag]);
+ ClassSymbol sym = reader.enterClass(boxedName[type.tag.ordinal()]);
final Completer completer = sym.completer;
if (completer != null) {
sym.completer = new Completer() {
@@ -366,7 +367,7 @@
target = Target.instance(context);
// Create the unknown type
- unknownType = new Type(TypeTags.UNKNOWN, null) {
+ unknownType = new Type(UNKNOWN, null) {
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
return v.visitUnknown(this, p);
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Type.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Type.java Thu Oct 25 11:09:36 2012 -0700
@@ -38,7 +38,7 @@
import static com.sun.tools.javac.code.BoundKind.*;
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.*;
/** This class represents Java types. The class itself defines the behavior of
* the following types:
@@ -66,7 +66,7 @@
* This code and its internal interfaces are subject to change or
* deletion without notice.</b>
*
- * @see TypeTags
+ * @see TypeTag
*/
public class Type implements PrimitiveType {
@@ -83,15 +83,77 @@
/** The tag of this type.
*
- * @see TypeTags
+ * @see TypeTag
*/
- public int tag;
+ 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;
+ }
+
+ /**
+ * Returns the current type tag.
+ * @return the value of the current type tag.
+ */
+ public TypeTag getTag() {
+ return tag;
+ }
+
+ public boolean isNumeric() {
+ switch (tag) {
+ case BYTE: case CHAR:
+ case SHORT:
+ case INT: case LONG:
+ case FLOAT: case DOUBLE:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ public boolean isPrimitive() {
+ return (isNumeric() || tag == BOOLEAN);
+ }
+
+ public boolean isPrimitiveOrVoid() {
+ return (isPrimitive() || tag == VOID);
+ }
+
+ public boolean isReference() {
+ switch (tag) {
+ case CLASS:
+ case ARRAY:
+ case TYPEVAR:
+ case WILDCARD:
+ case ERROR:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ public boolean isNullOrReference() {
+ return (tag == BOT || isReference());
+ }
+
+ public boolean isPartial() {
+ switch(tag) {
+ case ERROR: case UNKNOWN: case UNDETVAR:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ /**
* The constant value of this type, null if this type does not
* have a constant value attribute. Only primitive types and
* strings (ClassType) can have a constant value attribute.
@@ -121,7 +183,7 @@
/** Define a type given its tag and type symbol
*/
- public Type(int tag, TypeSymbol tsym) {
+ public Type(TypeTag tag, TypeSymbol tsym) {
this.tag = tag;
this.tsym = tsym;
}
@@ -162,7 +224,7 @@
*/
public Type constType(Object constValue) {
final Object value = constValue;
- Assert.check(tag <= BOOLEAN);
+ Assert.check(isPrimitive());
return new Type(tag, tsym) {
@Override
public Object constValue() {
@@ -352,10 +414,6 @@
return (tsym.flags() & FINAL) != 0;
}
- public boolean isPrimitive() {
- return tag < VOID;
- }
-
/**
* Does this type contain occurrences of type t?
*/
@@ -808,7 +866,7 @@
}
public int hashCode() {
- return (ARRAY << 5) + elemtype.hashCode();
+ return (ARRAY.ordinal() << 5) + elemtype.hashCode();
}
public boolean isVarargs() {
@@ -915,7 +973,7 @@
}
public int hashCode() {
- int h = METHOD;
+ int h = METHOD.ordinal();
for (List<Type> thisargs = this.argtypes;
thisargs.tail != null; /*inlined: thisargs.nonEmpty()*/
thisargs = thisargs.tail)
@@ -1099,7 +1157,7 @@
public static abstract class DelegatedType extends Type {
public Type qtype;
- public DelegatedType(int tag, Type qtype) {
+ public DelegatedType(TypeTag tag, Type qtype) {
super(tag, qtype.tsym);
this.qtype = qtype;
}
@@ -1285,7 +1343,7 @@
/** Represents VOID or NONE.
*/
static class JCNoType extends Type implements NoType {
- public JCNoType(int tag) {
+ public JCNoType(TypeTag tag) {
super(tag, null);
}
@@ -1307,7 +1365,7 @@
static class BottomType extends Type implements NullType {
public BottomType() {
- super(TypeTags.BOT, null);
+ super(BOT, null);
}
@Override
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/TypeTag.java Thu Oct 25 11:09:36 2012 -0700
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.tools.javac.code;
+
+import com.sun.source.tree.Tree.Kind;
+
+import javax.lang.model.type.TypeKind;
+
+/** An interface for type tag values, which distinguish between different
+ * sorts of types.
+ *
+ * <p><b>This is NOT part of any supported API.
+ * If you write code that depends on this, you do so at your own risk.
+ * This code and its internal interfaces are subject to change or
+ * deletion without notice.</b>
+ */
+public enum TypeTag {
+ /** The tag of the basic type `byte'.
+ */
+ BYTE(1),
+
+ /** The tag of the basic type `char'.
+ */
+ CHAR(2),
+
+ /** The tag of the basic type `short'.
+ */
+ SHORT(3),
+
+ /** The tag of the basic type `int'.
+ */
+ INT(4),
+
+ /** The tag of the basic type `long'.
+ */
+ LONG(5),
+
+ /** The tag of the basic type `float'.
+ */
+ FLOAT(6),
+
+ /** The tag of the basic type `double'.
+ */
+ DOUBLE(7),
+
+ /** The tag of the basic type `boolean'.
+ */
+ BOOLEAN,
+
+ /** The tag of the type `void'.
+ */
+ VOID,
+
+ /** The tag of all class and interface types.
+ */
+ CLASS,
+
+ /** The tag of all array types.
+ */
+ ARRAY,
+
+ /** The tag of all (monomorphic) method types.
+ */
+ METHOD,
+
+ /** The tag of all package "types".
+ */
+ PACKAGE,
+
+ /** The tag of all (source-level) type variables.
+ */
+ TYPEVAR,
+
+ /** The tag of all type arguments.
+ */
+ WILDCARD,
+
+ /** The tag of all polymorphic (method-) types.
+ */
+ FORALL,
+
+ /** The tag of deferred expression types in method context
+ */
+ DEFERRED,
+
+ /** The tag of the bottom type <null>.
+ */
+ BOT,
+
+ /** The tag of a missing type.
+ */
+ NONE,
+
+ /** The tag of the error type.
+ */
+ ERROR,
+
+ /** The tag of an unknown type
+ */
+ UNKNOWN,
+
+ /** The tag of all instantiatable type variables.
+ */
+ UNDETVAR,
+
+ /** Pseudo-types, these are special tags
+ */
+ UNINITIALIZED_THIS,
+
+ UNINITIALIZED_OBJECT;
+
+ /** This field will only be used for tags related with numeric types for
+ * optimization reasons.
+ */
+ private int order = 0;
+
+ private TypeTag() {}
+
+ private TypeTag(int order) {
+ this.order = order;
+ }
+
+ private static final int MIN_NUMERIC_TAG_ORDER = 1;
+ private static final int MAX_NUMERIC_TAG_ORDER = 7;
+
+ /** Returns the number of type tags.
+ */
+ public static int getTypeTagCount() {
+ // last two tags are not included in the total as long as they are pseudo-types
+ return (UNDETVAR.ordinal() + 1);
+ }
+
+ public boolean isSubRangeOf(TypeTag range) {
+ return (this == range) || isStrictSubRangeOf(range);
+ }
+
+ public boolean isStrictSubRangeOf(TypeTag range) {
+ if (this.order >= MIN_NUMERIC_TAG_ORDER && this.order <= MAX_NUMERIC_TAG_ORDER &&
+ range.order >= MIN_NUMERIC_TAG_ORDER && this.order <= MAX_NUMERIC_TAG_ORDER) {
+ if (this == range)
+ return false;
+ switch (this) {
+ case BYTE:
+ return true;
+ case CHAR: case SHORT: case INT:
+ case LONG: case FLOAT:
+ return this.order < range.order && range.order <= MAX_NUMERIC_TAG_ORDER;
+ default:
+ return false;
+ }
+ }
+ else
+ return false;
+ }
+
+ public Kind getKindLiteral() {
+ switch (this) {
+ case INT:
+ return Kind.INT_LITERAL;
+ case LONG:
+ return Kind.LONG_LITERAL;
+ case FLOAT:
+ return Kind.FLOAT_LITERAL;
+ case DOUBLE:
+ return Kind.DOUBLE_LITERAL;
+ case BOOLEAN:
+ return Kind.BOOLEAN_LITERAL;
+ case CHAR:
+ return Kind.CHAR_LITERAL;
+ case CLASS:
+ return Kind.STRING_LITERAL;
+ case BOT:
+ return Kind.NULL_LITERAL;
+ default:
+ throw new AssertionError("unknown literal kind " + this);
+ }
+ }
+
+ public TypeKind getPrimitiveTypeKind() {
+ switch (this) {
+ case BOOLEAN:
+ return TypeKind.BOOLEAN;
+ case BYTE:
+ return TypeKind.BYTE;
+ case SHORT:
+ return TypeKind.SHORT;
+ case INT:
+ return TypeKind.INT;
+ case LONG:
+ return TypeKind.LONG;
+ case CHAR:
+ return TypeKind.CHAR;
+ case FLOAT:
+ return TypeKind.FLOAT;
+ case DOUBLE:
+ return TypeKind.DOUBLE;
+ case VOID:
+ return TypeKind.VOID;
+ default:
+ throw new AssertionError("unknown primitive type " + this);
+ }
+ }
+}
--- a/langtools/src/share/classes/com/sun/tools/javac/code/TypeTags.java Tue Oct 23 13:58:56 2012 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,140 +0,0 @@
-/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package com.sun.tools.javac.code;
-
-
-/** An interface for type tag values, which distinguish between different
- * sorts of types.
- *
- * <p><b>This is NOT part of any supported API.
- * If you write code that depends on this, you do so at your own risk.
- * This code and its internal interfaces are subject to change or
- * deletion without notice.</b>
- */
-public class TypeTags {
-
- private TypeTags() {} // uninstantiable
-
- /** The tag of the basic type `byte'.
- */
- public static final int BYTE = 1;
-
- /** The tag of the basic type `char'.
- */
- public static final int CHAR = BYTE+1;
-
- /** The tag of the basic type `short'.
- */
- public static final int SHORT = CHAR+1;
-
- /** The tag of the basic type `int'.
- */
- public static final int INT = SHORT+1;
-
- /** The tag of the basic type `long'.
- */
- public static final int LONG = INT+1;
-
- /** The tag of the basic type `float'.
- */
- public static final int FLOAT = LONG+1;
-
- /** The tag of the basic type `double'.
- */
- public static final int DOUBLE = FLOAT+1;
-
- /** The tag of the basic type `boolean'.
- */
- public static final int BOOLEAN = DOUBLE+1;
-
- /** The tag of the type `void'.
- */
- public static final int VOID = BOOLEAN+1;
-
- /** The tag of all class and interface types.
- */
- public static final int CLASS = VOID+1;
-
- /** The tag of all array types.
- */
- public static final int ARRAY = CLASS+1;
-
- /** The tag of all (monomorphic) method types.
- */
- public static final int METHOD = ARRAY+1;
-
- /** The tag of all package "types".
- */
- public static final int PACKAGE = METHOD+1;
-
- /** The tag of all (source-level) type variables.
- */
- public static final int TYPEVAR = PACKAGE+1;
-
- /** The tag of all type arguments.
- */
- public static final int WILDCARD = TYPEVAR+1;
-
- /** The tag of all polymorphic (method-) types.
- */
- public static final int FORALL = WILDCARD+1;
-
- /** The tag of deferred expression types in method context
- */
- public static final int DEFERRED = FORALL+1;
-
- /** The tag of the bottom type {@code <null>}.
- */
- public static final int BOT = DEFERRED+1;
-
- /** The tag of a missing type.
- */
- public static final int NONE = BOT+1;
-
- /** The tag of the error type.
- */
- public static final int ERROR = NONE+1;
-
- /** The tag of an unknown type
- */
- public static final int UNKNOWN = ERROR+1;
-
- /** The tag of all instantiatable type variables.
- */
- public static final int UNDETVAR = UNKNOWN+1;
-
- /** The number of type tags.
- */
- public static final int TypeTagCount = UNDETVAR+1;
-
- /** The maximum tag of a basic type.
- */
- public static final int lastBaseTag = BOOLEAN;
-
- /** The minimum tag of a partial type
- */
- public static final int firstPartialTag = ERROR;
-}
--- a/langtools/src/share/classes/com/sun/tools/javac/code/Types.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/code/Types.java Thu Oct 25 11:09:36 2012 -0700
@@ -40,7 +40,7 @@
import static com.sun.tools.javac.code.Scope.*;
import static com.sun.tools.javac.code.Symbol.*;
import static com.sun.tools.javac.code.Type.*;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.*;
import static com.sun.tools.javac.util.ListBuffer.lb;
/**
@@ -605,8 +605,8 @@
}
//where
private boolean isSubtypeUncheckedInternal(Type t, Type s, Warner warn) {
- if (t.tag == ARRAY && s.tag == ARRAY) {
- if (((ArrayType)t).elemtype.tag <= lastBaseTag) {
+ if (t.hasTag(ARRAY) && s.hasTag(ARRAY)) {
+ if (((ArrayType)t).elemtype.isPrimitive()) {
return isSameType(elemtype(t), elemtype(s));
} else {
return isSubtypeUnchecked(elemtype(t), elemtype(s), warn);
@@ -664,7 +664,7 @@
if (t == s)
return true;
- if (s.tag >= firstPartialTag)
+ if (s.isPartial())
return isSuperType(s, t);
if (s.isCompound()) {
@@ -686,25 +686,27 @@
{
public Boolean visitType(Type t, Type s) {
switch (t.tag) {
- case BYTE: case CHAR:
- return (t.tag == s.tag ||
- t.tag + 2 <= s.tag && s.tag <= DOUBLE);
- case SHORT: case INT: case LONG: case FLOAT: case DOUBLE:
- return t.tag <= s.tag && s.tag <= DOUBLE;
- case BOOLEAN: case VOID:
- return t.tag == s.tag;
- case TYPEVAR:
- return isSubtypeNoCapture(t.getUpperBound(), s);
- case BOT:
- return
- s.tag == BOT || s.tag == CLASS ||
- s.tag == ARRAY || s.tag == TYPEVAR;
- case WILDCARD: //we shouldn't be here - avoids crash (see 7034495)
- case NONE:
- return false;
- default:
- throw new AssertionError("isSubtype " + t.tag);
- }
+ case BYTE:
+ return (!s.hasTag(CHAR) && t.getTag().isSubRangeOf(s.getTag()));
+ case CHAR:
+ return (!s.hasTag(SHORT) && t.getTag().isSubRangeOf(s.getTag()));
+ case SHORT: case INT: case LONG:
+ case FLOAT: case DOUBLE:
+ return t.getTag().isSubRangeOf(s.getTag());
+ case BOOLEAN: case VOID:
+ return t.hasTag(s.getTag());
+ case TYPEVAR:
+ return isSubtypeNoCapture(t.getUpperBound(), s);
+ case BOT:
+ return
+ s.hasTag(BOT) || s.hasTag(CLASS) ||
+ s.hasTag(ARRAY) || s.hasTag(TYPEVAR);
+ case WILDCARD: //we shouldn't be here - avoids crash (see 7034495)
+ case NONE:
+ return false;
+ default:
+ throw new AssertionError("isSubtype " + t.tag);
+ }
}
private Set<TypePair> cache = new HashSet<TypePair>();
@@ -774,7 +776,7 @@
@Override
public Boolean visitArrayType(ArrayType t, Type s) {
if (s.tag == ARRAY) {
- if (t.elemtype.tag <= lastBaseTag)
+ if (t.elemtype.isPrimitive())
return isSameType(t.elemtype, elemtype(s));
else
return isSubtypeNoCapture(t.elemtype, elemtype(s));
@@ -907,7 +909,7 @@
if (t == s)
return true;
- if (s.tag >= firstPartialTag)
+ if (s.isPartial())
return visit(s, t);
switch (t.tag) {
@@ -936,7 +938,7 @@
@Override
public Boolean visitWildcardType(WildcardType t, Type s) {
- if (s.tag >= firstPartialTag)
+ if (s.isPartial())
return visit(s, t);
else
return false;
@@ -947,7 +949,7 @@
if (t == s)
return true;
- if (s.tag >= firstPartialTag)
+ if (s.isPartial())
return visit(s, t);
if (s.isSuperBound() && !s.isExtendsBound())
@@ -976,10 +978,10 @@
if (t == s)
return true;
- if (s.tag >= firstPartialTag)
+ if (s.isPartial())
return visit(s, t);
- return s.tag == ARRAY
+ return s.hasTag(ARRAY)
&& containsTypeEquivalent(t.elemtype, elemtype(s));
}
@@ -1120,7 +1122,7 @@
}
public Boolean visitType(Type t, Type s) {
- if (s.tag >= firstPartialTag)
+ if (s.isPartial())
return containedBy(s, t);
else
return isSameType(t, s);
@@ -1142,7 +1144,7 @@
@Override
public Boolean visitWildcardType(WildcardType t, Type s) {
- if (s.tag >= firstPartialTag)
+ if (s.isPartial())
return containedBy(s, t);
else {
// debugContainsType(t, s);
@@ -1232,7 +1234,7 @@
switch (t.tag) {
case BYTE: case CHAR: case SHORT: case INT: case LONG: case FLOAT:
case DOUBLE:
- return s.tag <= DOUBLE;
+ return s.isNumeric();
case BOOLEAN:
return s.tag == BOOLEAN;
case VOID:
@@ -1373,8 +1375,7 @@
case CLASS:
return isSubtype(t, s);
case ARRAY:
- if (elemtype(t).tag <= lastBaseTag ||
- elemtype(s).tag <= lastBaseTag) {
+ if (elemtype(t).isPrimitive() || elemtype(s).isPrimitive()) {
return elemtype(t).tag == elemtype(s).tag;
} else {
return visit(elemtype(t), elemtype(s));
@@ -1648,8 +1649,8 @@
*/
public ArrayType makeArrayType(Type t) {
if (t.tag == VOID ||
- t.tag >= PACKAGE) {
- Assert.error("Type t must not be a a VOID or PACKAGE type, " + t.toString());
+ t.tag == PACKAGE) {
+ Assert.error("Type t must not be a VOID or PACKAGE type, " + t.toString());
}
return new ArrayType(t, syms.arrayClass);
}
@@ -1847,7 +1848,7 @@
public boolean isAssignable(Type t, Type s, Warner warn) {
if (t.tag == ERROR)
return true;
- if (t.tag <= INT && t.constValue() != null) {
+ if (t.tag.isSubRangeOf(INT) && t.constValue() != null) {
int value = ((Number)t.constValue()).intValue();
switch (s.tag) {
case BYTE:
@@ -1891,11 +1892,11 @@
// We don't want to erase primitive types and String type as that
// operation is idempotent. Also, erasing these could result in loss
// of information such as constant values attached to such types.
- return (t.tag <= lastBaseTag) || (syms.stringType.tsym == t.tsym);
+ return (t.isPrimitive()) || (syms.stringType.tsym == t.tsym);
}
private Type erasure(Type t, boolean recurse) {
- if (t.tag <= lastBaseTag)
+ if (t.isPrimitive())
return t; /* fast special case */
else
return erasure.visit(t, recurse);
@@ -1903,7 +1904,7 @@
// where
private SimpleVisitor<Type, Boolean> erasure = new SimpleVisitor<Type, Boolean>() {
public Type visitType(Type t, Boolean recurse) {
- if (t.tag <= lastBaseTag)
+ if (t.isPrimitive())
return t; /*fast special case*/
else
return t.map(recurse ? erasureRecFun : erasureFun);
@@ -3314,7 +3315,7 @@
private static final UnaryVisitor<Integer> hashCode = new UnaryVisitor<Integer>() {
public Integer visitType(Type t, Void ignored) {
- return t.tag;
+ return t.tag.ordinal();
}
@Override
@@ -3430,7 +3431,7 @@
* Return the class that boxes the given primitive.
*/
public ClassSymbol boxedClass(Type t) {
- return reader.enterClass(syms.boxedName[t.tag]);
+ return reader.enterClass(syms.boxedName[t.tag.ordinal()]);
}
/**
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java Thu Oct 25 11:09:36 2012 -0700
@@ -34,6 +34,8 @@
import com.sun.tools.javac.tree.*;
import com.sun.tools.javac.tree.JCTree.*;
+import static com.sun.tools.javac.code.TypeTag.ARRAY;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
/** Enter annotations on symbols. Annotations accumulate in a queue,
@@ -289,7 +291,7 @@
}
return enterAnnotation((JCAnnotation)tree, expected, env);
}
- if (expected.tag == TypeTags.ARRAY) { // should really be isArray()
+ if (expected.hasTag(ARRAY)) { // should really be isArray()
if (!tree.hasTag(NEWARRAY)) {
tree = make.at(tree.pos).
NewArray(null, List.<JCExpression>nil(), List.of(tree));
@@ -309,7 +311,7 @@
return new Attribute.
Array(expected, buf.toArray(new Attribute[buf.length()]));
}
- if (expected.tag == TypeTags.CLASS &&
+ if (expected.hasTag(CLASS) &&
(expected.tsym.flags() & Flags.ENUM) != 0) {
attr.attribExpr(tree, env, expected);
Symbol sym = TreeInfo.symbol(tree);
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java Thu Oct 25 11:09:36 2012 -0700
@@ -56,8 +56,8 @@
import static com.sun.tools.javac.code.Flags.BLOCK;
import static com.sun.tools.javac.code.Kinds.*;
import static com.sun.tools.javac.code.Kinds.ERRONEOUS;
-import static com.sun.tools.javac.code.TypeTags.*;
-import static com.sun.tools.javac.code.TypeTags.WILDCARD;
+import static com.sun.tools.javac.code.TypeTag.*;
+import static com.sun.tools.javac.code.TypeTag.WILDCARD;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
/** This is the main context-dependent analysis phase in GJC. It
@@ -234,7 +234,7 @@
Type check(final JCTree tree, final Type found, final int ownkind, final ResultInfo resultInfo) {
InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
Type owntype = found;
- if (owntype.tag != ERROR && resultInfo.pt.tag != METHOD && resultInfo.pt.tag != FORALL) {
+ if (!owntype.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) {
if (inferenceContext.free(found)) {
inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() {
@Override
@@ -606,7 +606,7 @@
/** Derived visitor method: attribute an expression tree.
*/
public Type attribExpr(JCTree tree, Env<AttrContext> env, Type pt) {
- return attribTree(tree, env, new ResultInfo(VAL, pt.tag != ERROR ? pt : Type.noType));
+ return attribTree(tree, env, new ResultInfo(VAL, !pt.hasTag(ERROR) ? pt : Type.noType));
}
/** Derived visitor method: attribute an expression tree with
@@ -806,7 +806,7 @@
boolean checkExtensible) {
if (t.isErroneous())
return t;
- if (t.tag == TYPEVAR && !classExpected && !interfaceExpected) {
+ if (t.hasTag(TYPEVAR) && !classExpected && !interfaceExpected) {
// check that type variable is already visible
if (t.getUpperBound() == null) {
log.error(tree.pos(), "illegal.forward.ref");
@@ -1208,7 +1208,7 @@
}
} else {
Type pattype = attribExpr(c.pat, switchEnv, seltype);
- if (pattype.tag != ERROR) {
+ if (!pattype.hasTag(ERROR)) {
if (pattype.constValue() == null) {
log.error(c.pat.pos(),
(stringSwitch ? "string.const.req" : "const.expr.req"));
@@ -1379,10 +1379,10 @@
Type condtype = attribExpr(tree.cond, env, syms.booleanType);
boolean standaloneConditional = !allowPoly ||
- pt().tag == NONE && pt() != Type.recoveryType ||
+ pt().hasTag(NONE) && pt() != Type.recoveryType ||
isBooleanOrNumeric(env, tree);
- if (!standaloneConditional && resultInfo.pt.tag == VOID) {
+ if (!standaloneConditional && resultInfo.pt.hasTag(VOID)) {
//cannot get here (i.e. it means we are returning from void method - which is already an error)
result = tree.type = types.createErrorType(resultInfo.pt);
return;
@@ -1416,7 +1416,8 @@
@SuppressWarnings("fallthrough")
private boolean isBooleanOrNumeric(Env<AttrContext> env, JCExpression tree) {
switch (tree.getTag()) {
- case LITERAL: return ((JCLiteral)tree).typetag < CLASS;
+ case LITERAL: return ((JCLiteral)tree).typetag.isSubRangeOf(DOUBLE) ||
+ ((JCLiteral)tree).typetag == BOOLEAN;
case LAMBDA: case REFERENCE: return false;
case PARENS: return isBooleanOrNumeric(env, ((JCParens)tree).expr);
case CONDEXPR:
@@ -1426,7 +1427,7 @@
default:
Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo).type;
speculativeType = types.unboxedTypeOrType(speculativeType);
- return speculativeType.tag <= BOOLEAN;
+ return speculativeType.isPrimitive();
}
}
@@ -1459,16 +1460,19 @@
// If one arm has an integer subrange type (i.e., byte,
// short, or char), and the other is an integer constant
// that fits into the subrange, return the subrange type.
- if (thenUnboxed.tag < INT && elseUnboxed.tag == INT &&
+ if (thenUnboxed.getTag().isStrictSubRangeOf(INT) && elseUnboxed.hasTag(INT) &&
types.isAssignable(elseUnboxed, thenUnboxed))
return thenUnboxed.baseType();
- if (elseUnboxed.tag < INT && thenUnboxed.tag == INT &&
+ if (elseUnboxed.getTag().isStrictSubRangeOf(INT) && thenUnboxed.hasTag(INT) &&
types.isAssignable(thenUnboxed, elseUnboxed))
return elseUnboxed.baseType();
- for (int i = BYTE; i < VOID; i++) {
- Type candidate = syms.typeOfTag[i];
- if (types.isSubtype(thenUnboxed, candidate) &&
+ for (TypeTag tag : TypeTag.values()) {
+ if (tag.ordinal() >= TypeTag.getTypeTagCount()) break;
+ Type candidate = syms.typeOfTag[tag.ordinal()];
+ if (candidate != null &&
+ candidate.isPrimitive() &&
+ types.isSubtype(thenUnboxed, candidate) &&
types.isSubtype(elseUnboxed, candidate))
return candidate;
}
@@ -1487,7 +1491,7 @@
if (types.isSubtype(elsetype, thentype))
return thentype.baseType();
- if (!allowBoxing || thentype.tag == VOID || elsetype.tag == VOID) {
+ if (!allowBoxing || thentype.hasTag(VOID) || elsetype.hasTag(VOID)) {
log.error(pos, "neither.conditional.subtype",
thentype, elsetype);
return thentype.baseType();
@@ -1601,12 +1605,12 @@
// Attribute return expression, if it exists, and check that
// it conforms to result type of enclosing method.
if (tree.expr != null) {
- if (env.info.returnResult.pt.tag == VOID) {
+ if (env.info.returnResult.pt.hasTag(VOID)) {
log.error(tree.expr.pos(),
"cant.ret.val.from.meth.decl.void");
}
attribTree(tree.expr, env, env.info.returnResult);
- } else if (env.info.returnResult.pt.tag != VOID) {
+ } else if (!env.info.returnResult.pt.hasTag(VOID)) {
log.error(tree.pos(), "missing.ret.val");
}
}
@@ -1671,11 +1675,11 @@
}
}
- if (site.tag == CLASS) {
+ if (site.hasTag(CLASS)) {
Type encl = site.getEnclosingType();
- while (encl != null && encl.tag == TYPEVAR)
+ while (encl != null && encl.hasTag(TYPEVAR))
encl = encl.getUpperBound();
- if (encl.tag == CLASS) {
+ if (encl.hasTag(CLASS)) {
// we are calling a nested class
if (tree.meth.hasTag(SELECT)) {
@@ -1740,7 +1744,7 @@
// Compute the result type.
Type restype = mtype.getReturnType();
- if (restype.tag == WILDCARD)
+ if (restype.hasTag(WILDCARD))
throw new AssertionError(mtype);
Type qualifier = (tree.meth.hasTag(SELECT))
@@ -1870,7 +1874,7 @@
}
}
} else if (!clazztype.tsym.isInterface() &&
- clazztype.getEnclosingType().tag == CLASS) {
+ clazztype.getEnclosingType().hasTag(CLASS)) {
// Check for the existence of an apropos outer instance
rs.resolveImplicitThis(tree.pos(), env, clazztype);
}
@@ -1880,7 +1884,7 @@
List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);
// If we have made no mistakes in the class type...
- if (clazztype.tag == CLASS) {
+ if (clazztype.hasTag(CLASS)) {
// Enums may not be instantiated except implicitly
if (allowEnums &&
(clazztype.tsym.flags_field&Flags.ENUM) != 0 &&
@@ -2058,7 +2062,7 @@
resultInfo.checkContext.inferenceContext().free(resultInfo.pt) ? Type.noType : pt());
Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
if (!inferred.isErroneous() &&
- types.isAssignable(inferred, pt().tag == NONE ? syms.objectType : pt(), Warner.noWarnings)) {
+ types.isAssignable(inferred, pt().hasTag(NONE) ? syms.objectType : pt(), Warner.noWarnings)) {
String key = types.isSameType(clazztype, inferred) ?
"diamond.redundant.args" :
"diamond.redundant.args.1";
@@ -2073,8 +2077,8 @@
private void checkLambdaCandidate(JCNewClass tree, ClassSymbol csym, Type clazztype) {
if (allowLambda &&
identifyLambdaCandidate &&
- clazztype.tag == CLASS &&
- pt().tag != NONE &&
+ clazztype.hasTag(CLASS) &&
+ !pt().hasTag(NONE) &&
types.isFunctionalInterface(clazztype.tsym)) {
Symbol descriptor = types.findDescriptorSymbol(clazztype.tsym);
int count = 0;
@@ -2125,10 +2129,10 @@
} else {
// we are seeing an untyped aggregate { ... }
// this is allowed only if the prototype is an array
- if (pt().tag == ARRAY) {
+ if (pt().hasTag(ARRAY)) {
elemtype = types.elemtype(pt());
} else {
- if (pt().tag != ERROR) {
+ if (!pt().hasTag(ERROR)) {
log.error(tree.pos(), "illegal.initializer.for.type",
pt());
}
@@ -2152,8 +2156,8 @@
*/
@Override
public void visitLambda(final JCLambda that) {
- if (pt().isErroneous() || (pt().tag == NONE && pt() != Type.recoveryType)) {
- if (pt().tag == NONE) {
+ if (pt().isErroneous() || (pt().hasTag(NONE) && pt() != Type.recoveryType)) {
+ if (pt().hasTag(NONE)) {
//lambda only allowed in assignment or method invocation/cast context
log.error(that.pos(), "unexpected.lambda");
}
@@ -2328,7 +2332,7 @@
//this amounts at checking that, if a lambda body can complete normally,
//the descriptor's return type must be void
if (tree.getBodyKind() == JCLambda.BodyKind.STATEMENT && tree.canCompleteNormally &&
- returnType.tag != VOID && returnType != Type.recoveryType) {
+ !returnType.hasTag(VOID) && returnType != Type.recoveryType) {
checkContext.report(tree, diags.fragment("incompatible.ret.type.in.lambda",
diags.fragment("missing.ret.val", returnType)));
}
@@ -2363,8 +2367,8 @@
@Override
public void visitReference(final JCMemberReference that) {
- if (pt().isErroneous() || (pt().tag == NONE && pt() != Type.recoveryType)) {
- if (pt().tag == NONE) {
+ if (pt().isErroneous() || (pt().hasTag(NONE) && pt() != Type.recoveryType)) {
+ if (pt().hasTag(NONE)) {
//method reference only allowed in assignment or method invocation/cast context
log.error(that.pos(), "unexpected.mref");
}
@@ -2465,7 +2469,7 @@
ResultInfo checkInfo =
resultInfo.dup(newMethodTemplate(
- desc.getReturnType().tag == VOID ? Type.noType : desc.getReturnType(),
+ desc.getReturnType().hasTag(VOID) ? Type.noType : desc.getReturnType(),
lookupHelper.argtypes,
typeargtypes));
@@ -2510,11 +2514,11 @@
Type incompatibleReturnType = resType;
- if (returnType.tag == VOID) {
+ if (returnType.hasTag(VOID)) {
incompatibleReturnType = null;
}
- if (returnType.tag != VOID && resType.tag != VOID) {
+ if (!returnType.hasTag(VOID) && !resType.hasTag(VOID)) {
if (resType.isErroneous() ||
new LambdaReturnContext(checkContext).compatible(resType, returnType, Warner.noWarnings)) {
incompatibleReturnType = null;
@@ -2711,7 +2715,7 @@
attribExpr(tree.index, env, syms.intType);
if (types.isArray(atype))
owntype = types.elemtype(atype);
- else if (atype.tag != ERROR)
+ else if (!atype.hasTag(ERROR))
log.error(tree.pos(), "array.req.but.found", atype);
if ((pkind() & VAR) == 0) owntype = capture(owntype);
result = check(tree, owntype, VAR, resultInfo);
@@ -2721,7 +2725,7 @@
Symbol sym;
// Find symbol
- if (pt().tag == METHOD || pt().tag == FORALL) {
+ if (pt().hasTag(METHOD) || pt().hasTag(FORALL)) {
// If we are looking for a method, the prototype `pt' will be a
// method type with the type of the call's arguments as parameters.
env.info.pendingResolutionPhase = null;
@@ -2811,9 +2815,9 @@
// don't allow T.class T[].class, etc
if (skind == TYP) {
Type elt = site;
- while (elt.tag == ARRAY)
+ while (elt.hasTag(ARRAY))
elt = ((ArrayType)elt).elemtype;
- if (elt.tag == TYPEVAR) {
+ if (elt.hasTag(TYPEVAR)) {
log.error(tree.pos(), "type.var.cant.be.deref");
result = types.createErrorType(tree.type);
return;
@@ -2839,8 +2843,8 @@
boolean varArgs = env.info.lastResolveVarargs();
tree.sym = sym;
- if (site.tag == TYPEVAR && !isType(sym) && sym.kind != ERR) {
- while (site.tag == TYPEVAR) site = site.getUpperBound();
+ if (site.hasTag(TYPEVAR) && !isType(sym) && sym.kind != ERR) {
+ while (site.hasTag(TYPEVAR)) site = site.getUpperBound();
site = capture(site);
}
@@ -2929,14 +2933,14 @@
ResultInfo resultInfo) {
DiagnosticPosition pos = tree.pos();
Name name = tree.name;
- switch (site.tag) {
+ switch (site.getTag()) {
case PACKAGE:
return rs.accessBase(
rs.findIdentInPackage(env, site.tsym, name, resultInfo.pkind),
pos, location, site, name, true);
case ARRAY:
case CLASS:
- if (resultInfo.pt.tag == METHOD || resultInfo.pt.tag == FORALL) {
+ if (resultInfo.pt.hasTag(METHOD) || resultInfo.pt.hasTag(FORALL)) {
return rs.resolveQualifiedMethod(
pos, env, location, site, name, resultInfo.pt.getParameterTypes(), resultInfo.pt.getTypeArguments());
} else if (name == names._this || name == names._super) {
@@ -3029,7 +3033,7 @@
Symbol sym,
Env<AttrContext> env,
ResultInfo resultInfo) {
- Type pt = resultInfo.pt.tag == FORALL || resultInfo.pt.tag == METHOD ?
+ Type pt = resultInfo.pt.hasTag(FORALL) || resultInfo.pt.hasTag(METHOD) ?
resultInfo.pt.map(deferredAttr.new DeferredTypeMap(AttrMode.SPECULATIVE, sym, env.info.pendingResolutionPhase)) :
resultInfo.pt;
@@ -3046,7 +3050,7 @@
// For types, the computed type equals the symbol's type,
// except for two situations:
owntype = sym.type;
- if (owntype.tag == CLASS) {
+ if (owntype.hasTag(CLASS)) {
Type ownOuter = owntype.getEnclosingType();
// (a) If the symbol's type is parameterized, erase it
@@ -3066,9 +3070,9 @@
//
// Then the type of the last expression above is
// Tree<Point>.Visitor.
- else if (ownOuter.tag == CLASS && site != ownOuter) {
+ else if (ownOuter.hasTag(CLASS) && site != ownOuter) {
Type normOuter = site;
- if (normOuter.tag == CLASS)
+ if (normOuter.hasTag(CLASS))
normOuter = types.asEnclosingSuper(site, ownOuter.tsym);
if (normOuter == null) // perhaps from an import
normOuter = types.erasure(ownOuter);
@@ -3087,7 +3091,7 @@
resultInfo.pkind == VAR &&
v.owner.kind == TYP &&
(v.flags() & STATIC) == 0 &&
- (site.tag == CLASS || site.tag == TYPEVAR)) {
+ (site.hasTag(CLASS) || site.hasTag(TYPEVAR))) {
Type s = types.asOuterSuper(site, v.owner);
if (s != null &&
s.isRaw() &&
@@ -3266,7 +3270,7 @@
// an unchecked warning if its argument types change under erasure.
if (allowGenerics &&
(sym.flags() & STATIC) == 0 &&
- (site.tag == CLASS || site.tag == TYPEVAR)) {
+ (site.hasTag(CLASS) || site.hasTag(TYPEVAR))) {
Type s = types.asOuterSuper(site, sym.owner);
if (s != null && s.isRaw() &&
!types.isSameTypes(sym.type.getParameterTypes(),
@@ -3312,12 +3316,12 @@
//where
/** Return the type of a literal with given type tag.
*/
- Type litType(int tag) {
- return (tag == TypeTags.CLASS) ? syms.stringType : syms.typeOfTag[tag];
+ Type litType(TypeTag tag) {
+ return (tag == CLASS) ? syms.stringType : syms.typeOfTag[tag.ordinal()];
}
public void visitTypeIdent(JCPrimitiveTypeTree tree) {
- result = check(tree, syms.typeOfTag[tree.typetag], TYP, resultInfo);
+ result = check(tree, syms.typeOfTag[tree.typetag.ordinal()], TYP, resultInfo);
}
public void visitTypeArray(JCArrayTypeTree tree) {
@@ -3339,7 +3343,7 @@
// Attribute type parameters
List<Type> actuals = attribTypes(tree.arguments, env);
- if (clazztype.tag == CLASS) {
+ if (clazztype.hasTag(CLASS)) {
List<Type> formals = clazztype.tsym.type.getTypeArguments();
if (actuals.isEmpty()) //diamond
actuals = formals;
@@ -3354,7 +3358,7 @@
}
// Compute the proper generic outer
Type clazzOuter = clazztype.getEnclosingType();
- if (clazzOuter.tag == CLASS) {
+ if (clazzOuter.hasTag(CLASS)) {
Type site;
JCExpression clazz = TreeInfo.typeIn(tree.clazz);
if (clazz.hasTag(IDENT)) {
@@ -3362,8 +3366,8 @@
} else if (clazz.hasTag(SELECT)) {
site = ((JCFieldAccess) clazz).selected.type;
} else throw new AssertionError(""+tree);
- if (clazzOuter.tag == CLASS && site != clazzOuter) {
- if (site.tag == CLASS)
+ if (clazzOuter.hasTag(CLASS) && site != clazzOuter) {
+ if (site.hasTag(CLASS))
site = types.asOuterSuper(site, clazzOuter.tsym);
if (site == null)
site = types.erasure(clazzOuter);
@@ -3419,7 +3423,7 @@
}
}
Type t = check(tree, types.lub(multicatchTypes.toList()), TYP, resultInfo);
- if (t.tag == CLASS) {
+ if (t.hasTag(CLASS)) {
List<Type> alternatives =
((all_multicatchTypes == null) ? multicatchTypes : all_multicatchTypes).toList();
t = new UnionClassType((ClassType) t, alternatives);
@@ -3440,7 +3444,7 @@
if (b.isErroneous()) {
a.bound = b;
}
- else if (b.tag == TYPEVAR) {
+ else if (b.hasTag(TYPEVAR)) {
// if first bound was a typevar, do not accept further bounds.
if (tree.bounds.tail.nonEmpty()) {
log.error(tree.bounds.tail.head.pos(),
@@ -3456,7 +3460,7 @@
Type i = checkBase(bs.head, bound, env, false, true, false);
if (i.isErroneous())
a.bound = i;
- else if (i.tag == CLASS)
+ else if (i.hasTag(CLASS))
chk.checkNotRepeated(bound.pos(), types.erasure(i), boundSet);
}
}
@@ -3568,7 +3572,7 @@
* @param c The class symbol whose definition will be attributed.
*/
void attribClass(ClassSymbol c) throws CompletionFailure {
- if (c.type.tag == ERROR) return;
+ if (c.type.hasTag(ERROR)) return;
// Check for cycles in the inheritance graph, which can arise from
// ill-formed class files.
@@ -3577,11 +3581,11 @@
Type st = types.supertype(c.type);
if ((c.flags_field & Flags.COMPOUND) == 0) {
// First, attribute superclass.
- if (st.tag == CLASS)
+ if (st.hasTag(CLASS))
attribClass((ClassSymbol)st.tsym);
// Next attribute owner, if it is a class.
- if (c.owner.kind == TYP && c.owner.type.tag == CLASS)
+ if (c.owner.kind == TYP && c.owner.type.hasTag(CLASS))
attribClass((ClassSymbol)c.owner);
}
@@ -3793,7 +3797,7 @@
TreeInfo.diagnosticPositionFor(svuid, tree), "improper.SVUID", c);
// check that it is long
- else if (svuid.type.tag != TypeTags.LONG)
+ else if (!svuid.type.hasTag(LONG))
log.warning(LintCategory.SERIAL,
TreeInfo.diagnosticPositionFor(svuid, tree), "long.SVUID", c);
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Thu Oct 25 11:09:36 2012 -0700
@@ -48,8 +48,8 @@
import static com.sun.tools.javac.code.Flags.ANNOTATION;
import static com.sun.tools.javac.code.Flags.SYNCHRONIZED;
import static com.sun.tools.javac.code.Kinds.*;
-import static com.sun.tools.javac.code.TypeTags.*;
-import static com.sun.tools.javac.code.TypeTags.WILDCARD;
+import static com.sun.tools.javac.code.TypeTag.*;
+import static com.sun.tools.javac.code.TypeTag.WILDCARD;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
@@ -280,7 +280,7 @@
Type typeTagError(DiagnosticPosition pos, Object required, Object found) {
// this error used to be raised by the parser,
// but has been delayed to this point:
- if (found instanceof Type && ((Type)found).tag == VOID) {
+ if (found instanceof Type && ((Type)found).hasTag(VOID)) {
log.error(pos, "illegal.start.of.type");
return syms.errType;
}
@@ -358,7 +358,7 @@
for (Scope.Entry e = s.next.lookup(c.name);
e.scope != null && e.sym.owner == c.owner;
e = e.next()) {
- if (e.sym.kind == TYP && e.sym.type.tag != TYPEVAR &&
+ if (e.sym.kind == TYP && !e.sym.type.hasTag(TYPEVAR) &&
(e.sym.owner.kind & (VAR | MTH)) != 0 &&
c.name != names.error) {
duplicateError(pos, e.sym);
@@ -527,14 +527,14 @@
}
});
}
- if (req.tag == ERROR)
+ if (req.hasTag(ERROR))
return req;
- if (req.tag == NONE)
+ if (req.hasTag(NONE))
return found;
if (checkContext.compatible(found, req, checkContext.checkWarner(pos, found, req))) {
return found;
} else {
- if (found.tag <= DOUBLE && req.tag <= DOUBLE) {
+ if (found.getTag().isSubRangeOf(DOUBLE) && req.getTag().isSubRangeOf(DOUBLE)) {
checkContext.report(pos, diags.fragment("possible.loss.of.precision", found, req));
return types.createErrorType(found);
}
@@ -594,7 +594,7 @@
* type variables?
*/
boolean isTypeVar(Type t) {
- return t.tag == TYPEVAR || t.tag == ARRAY && isTypeVar(types.elemtype(t));
+ return t.hasTag(TYPEVAR) || t.hasTag(ARRAY) && isTypeVar(types.elemtype(t));
}
/** Check that a type is within some bounds.
@@ -607,7 +607,7 @@
private boolean checkExtends(Type a, Type bound) {
if (a.isUnbound()) {
return true;
- } else if (a.tag != WILDCARD) {
+ } else if (!a.hasTag(WILDCARD)) {
a = types.upperBound(a);
return types.isSubtype(a, bound);
} else if (a.isExtendsBound()) {
@@ -623,7 +623,7 @@
* @param t The type to be checked.
*/
Type checkNonVoid(DiagnosticPosition pos, Type t) {
- if (t.tag == VOID) {
+ if (t.hasTag(VOID)) {
log.error(pos, "void.not.allowed.here");
return types.createErrorType(t);
} else {
@@ -636,10 +636,10 @@
* @param t The type to be checked.
*/
Type checkClassType(DiagnosticPosition pos, Type t) {
- if (t.tag != CLASS && t.tag != ERROR)
+ if (!t.hasTag(CLASS) && !t.hasTag(ERROR))
return typeTagError(pos,
diags.fragment("type.req.class"),
- (t.tag == TYPEVAR)
+ (t.hasTag(TYPEVAR))
? diags.fragment("type.parameter", t)
: t);
else
@@ -650,7 +650,7 @@
*/
Type checkConstructorRefType(DiagnosticPosition pos, Type t) {
t = checkClassType(pos, t);
- if (t.tag == CLASS) {
+ if (t.hasTag(CLASS)) {
if ((t.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
log.error(pos, "abstract.cant.be.instantiated");
t = types.createErrorType(t);
@@ -672,7 +672,7 @@
if (noBounds && t.isParameterized()) {
List<Type> args = t.getTypeArguments();
while (args.nonEmpty()) {
- if (args.head.tag == WILDCARD)
+ if (args.head.hasTag(WILDCARD))
return typeTagError(pos,
diags.fragment("type.req.exact"),
args.head);
@@ -687,7 +687,7 @@
* @param t The type to be checked.
*/
Type checkReifiableReferenceType(DiagnosticPosition pos, Type t) {
- if (t.tag != CLASS && t.tag != ARRAY && t.tag != ERROR) {
+ if (!t.hasTag(CLASS) && !t.hasTag(ARRAY) && !t.hasTag(ERROR)) {
return typeTagError(pos,
diags.fragment("type.req.class.array"),
t);
@@ -705,18 +705,12 @@
* @param t The type to be checked.
*/
Type checkRefType(DiagnosticPosition pos, Type t) {
- switch (t.tag) {
- case CLASS:
- case ARRAY:
- case TYPEVAR:
- case WILDCARD:
- case ERROR:
+ if (t.isReference())
return t;
- default:
+ else
return typeTagError(pos,
diags.fragment("type.req.ref"),
t);
- }
}
/** Check that each type is a reference type, i.e. a class, interface or array type
@@ -738,19 +732,12 @@
* @param t The type to be checked.
*/
Type checkNullOrRefType(DiagnosticPosition pos, Type t) {
- switch (t.tag) {
- case CLASS:
- case ARRAY:
- case TYPEVAR:
- case WILDCARD:
- case BOT:
- case ERROR:
+ if (t.isNullOrReference())
return t;
- default:
+ else
return typeTagError(pos,
diags.fragment("type.req.ref"),
t);
- }
}
/** Check that flag set does not contain elements of two conflicting sets. s
@@ -1054,7 +1041,7 @@
bounds = bounds_buf.toList();
for (Type arg : types.capture(type).getTypeArguments()) {
- if (arg.tag == TYPEVAR &&
+ if (arg.hasTag(TYPEVAR) &&
arg.getUpperBound().isErroneous() &&
!bounds.head.isErroneous() &&
!isTypeArgErroneous(args.head)) {
@@ -1309,7 +1296,7 @@
@Override
public void visitTypeApply(JCTypeApply tree) {
- if (tree.type.tag == CLASS) {
+ if (tree.type.hasTag(CLASS)) {
List<JCExpression> args = tree.arguments;
List<Type> forms = tree.type.tsym.type.getTypeArguments();
@@ -1360,7 +1347,7 @@
@Override
public void visitSelect(JCFieldAccess tree) {
- if (tree.type.tag == CLASS) {
+ if (tree.type.hasTag(CLASS)) {
visitSelectInternal(tree);
// Check that this type is either fully parameterized, or
@@ -1409,7 +1396,7 @@
void checkRaw(JCTree tree, Env<AttrContext> env) {
if (lint.isEnabled(LintCategory.RAW) &&
- tree.type.tag == CLASS &&
+ tree.type.hasTag(CLASS) &&
!TreeInfo.isDiamond(tree) &&
!withinAnonConstr(env) &&
tree.type.isRaw()) {
@@ -1511,9 +1498,9 @@
*/
boolean isUnchecked(Type exc) {
return
- (exc.tag == TYPEVAR) ? isUnchecked(types.supertype(exc)) :
- (exc.tag == CLASS) ? isUnchecked((ClassSymbol)exc.tsym) :
- exc.tag == BOT;
+ (exc.hasTag(TYPEVAR)) ? isUnchecked(types.supertype(exc)) :
+ (exc.hasTag(CLASS)) ? isUnchecked((ClassSymbol)exc.tsym) :
+ exc.hasTag(BOT);
}
/** Same, but handling completion failures.
@@ -1759,7 +1746,7 @@
// case, we will have dealt with when examining the supertype classes
ClassSymbol mc = m.enclClass();
Type st = types.supertype(origin.type);
- if (st.tag != CLASS)
+ if (!st.hasTag(CLASS))
return true;
MethodSymbol stimpl = m.implementation((ClassSymbol)st.tsym, types, false);
@@ -1782,7 +1769,7 @@
*/
public void checkCompatibleConcretes(DiagnosticPosition pos, Type site) {
Type sup = types.supertype(site);
- if (sup.tag != CLASS) return;
+ if (!sup.hasTag(CLASS)) return;
for (Type t1 = sup;
t1.tsym.type.isParameterized();
@@ -1803,7 +1790,7 @@
if (st1 == s1.type) continue;
for (Type t2 = sup;
- t2.tag == CLASS;
+ t2.hasTag(CLASS);
t2 = types.supertype(t2)) {
for (Scope.Entry e2 = t2.tsym.members().lookup(s1.name);
e2.scope != null;
@@ -1876,7 +1863,7 @@
/** Compute all the supertypes of t, indexed by type symbol. */
private void closure(Type t, Map<TypeSymbol,Type> typeMap) {
- if (t.tag != CLASS) return;
+ if (!t.hasTag(CLASS)) return;
if (typeMap.put(t.tsym, t) == null) {
closure(types.supertype(t), typeMap);
for (Type i : types.interfaces(t))
@@ -1886,7 +1873,7 @@
/** Compute all the supertypes of t, indexed by type symbol (except thise in typesSkip). */
private void closure(Type t, Map<TypeSymbol,Type> typesSkip, Map<TypeSymbol,Type> typeMap) {
- if (t.tag != CLASS) return;
+ if (!t.hasTag(CLASS)) return;
if (typesSkip.get(t.tsym) != null) return;
if (typeMap.put(t.tsym, t) == null) {
closure(types.supertype(t), typesSkip, typeMap);
@@ -1916,7 +1903,8 @@
Type rt2 = types.subst(st2.getReturnType(), tvars2, tvars1);
boolean compat =
types.isSameType(rt1, rt2) ||
- rt1.tag >= CLASS && rt2.tag >= CLASS &&
+ !rt1.isPrimitiveOrVoid() &&
+ !rt2.isPrimitiveOrVoid() &&
(types.covariantReturnType(rt1, rt2, Warner.noWarnings) ||
types.covariantReturnType(rt2, rt1, Warner.noWarnings)) ||
checkCommonOverriderIn(s1,s2,site);
@@ -1961,7 +1949,8 @@
Type rt13 = types.subst(st3.getReturnType(), tvars3, tvars1);
Type rt23 = types.subst(st3.getReturnType(), tvars3, tvars2);
boolean compat =
- rt13.tag >= CLASS && rt23.tag >= CLASS &&
+ !rt13.isPrimitiveOrVoid() &&
+ !rt23.isPrimitiveOrVoid() &&
(types.covariantReturnType(rt13, rt1, Warner.noWarnings) &&
types.covariantReturnType(rt23, rt2, Warner.noWarnings));
if (compat)
@@ -1984,7 +1973,7 @@
log.error(tree.pos(), "enum.no.finalize");
return;
}
- for (Type t = origin.type; t.tag == CLASS;
+ for (Type t = origin.type; t.hasTag(CLASS);
t = types.supertype(t)) {
if (t != origin.type) {
checkOverride(tree, t, origin, m);
@@ -2064,7 +2053,7 @@
}
if (undef == null) {
Type st = types.supertype(c.type);
- if (st.tag == CLASS)
+ if (st.hasTag(CLASS))
undef = firstUndef(impl, (ClassSymbol)st.tsym);
}
for (List<Type> l = types.interfaces(c.type);
@@ -2155,7 +2144,7 @@
} else if (!c.type.isErroneous()) {
try {
seenClasses = seenClasses.prepend(c);
- if (c.type.tag == CLASS) {
+ if (c.type.hasTag(CLASS)) {
if (supertypes.nonEmpty()) {
scan(supertypes);
}
@@ -2200,13 +2189,13 @@
private void checkNonCyclic1(DiagnosticPosition pos, Type t, List<TypeVar> seen) {
final TypeVar tv;
- if (t.tag == TYPEVAR && (t.tsym.flags() & UNATTRIBUTED) != 0)
+ if (t.hasTag(TYPEVAR) && (t.tsym.flags() & UNATTRIBUTED) != 0)
return;
if (seen.contains(t)) {
tv = (TypeVar)t;
tv.bound = types.createErrorType(t);
log.error(pos, "cyclic.inheritance", t);
- } else if (t.tag == TYPEVAR) {
+ } else if (t.hasTag(TYPEVAR)) {
tv = (TypeVar)t;
seen = seen.prepend(tv);
for (Type b : types.getBounds(tv))
@@ -2232,14 +2221,14 @@
} else if (!c.type.isErroneous()) {
try {
c.flags_field |= LOCKED;
- if (c.type.tag == CLASS) {
+ if (c.type.hasTag(CLASS)) {
ClassType clazz = (ClassType)c.type;
if (clazz.interfaces_field != null)
for (List<Type> l=clazz.interfaces_field; l.nonEmpty(); l=l.tail)
complete &= checkNonCyclicInternal(pos, l.head);
if (clazz.supertype_field != null) {
Type st = clazz.supertype_field;
- if (st != null && st.tag == CLASS)
+ if (st != null && st.hasTag(CLASS))
complete &= checkNonCyclicInternal(pos, st);
}
if (c.owner.kind == TYP)
@@ -2261,7 +2250,7 @@
for (List<Type> l=types.interfaces(c.type); l.nonEmpty(); l=l.tail)
l.head = types.createErrorType((ClassSymbol)l.head.tsym, Type.noType);
Type st = types.supertype(c.type);
- if (st.tag == CLASS)
+ if (st.hasTag(CLASS))
((ClassType)c.type).supertype_field = types.createErrorType((ClassSymbol)st.tsym, Type.noType);
c.type = types.createErrorType(c, c.type);
c.flags_field |= ACYCLIC;
@@ -2313,7 +2302,7 @@
void checkCompatibleSupertypes(DiagnosticPosition pos, Type c) {
List<Type> supertypes = types.interfaces(c);
Type supertype = types.supertype(c);
- if (supertype.tag == CLASS &&
+ if (supertype.hasTag(CLASS) &&
(supertype.tsym.flags() & ABSTRACT) != 0)
supertypes = supertypes.prepend(supertype);
for (List<Type> l = supertypes; l.nonEmpty(); l = l.tail) {
@@ -2542,7 +2531,7 @@
* @jls 9.6 Annotation Types
*/
void validateAnnotationMethod(DiagnosticPosition pos, MethodSymbol m) {
- for (Type sup = syms.annotationType; sup.tag == CLASS; sup = types.supertype(sup)) {
+ for (Type sup = syms.annotationType; sup.hasTag(CLASS); sup = types.supertype(sup)) {
Scope s = sup.tsym.members();
for (Scope.Entry e = s.lookup(m.name); e.scope != null; e = e.next()) {
if (e.sym.kind == MTH &&
@@ -2855,7 +2844,7 @@
{ if (s.kind == TYP ||
s.kind == VAR ||
(s.kind == MTH && !s.isConstructor() &&
- s.type.getReturnType().tag != VOID))
+ !s.type.getReturnType().hasTag(VOID)))
return true;
}
else
@@ -3016,12 +3005,12 @@
}
void checkAnnotationResType(DiagnosticPosition pos, Type type) {
- switch (type.tag) {
- case TypeTags.CLASS:
+ switch (type.getTag()) {
+ case CLASS:
if ((type.tsym.flags() & ANNOTATION) != 0)
checkNonCyclicElementsInternal(pos, type.tsym);
break;
- case TypeTags.ARRAY:
+ case ARRAY:
checkAnnotationResType(pos, types.elemtype(type));
break;
default:
@@ -3114,7 +3103,7 @@
void checkDivZero(DiagnosticPosition pos, Symbol operator, Type operand) {
if (operand.constValue() != null
&& lint.isEnabled(LintCategory.DIVZERO)
- && operand.tag <= LONG
+ && (operand.getTag().isSubRangeOf(LONG))
&& ((Number) (operand.constValue())).longValue() == 0) {
int opc = ((OperatorSymbol)operator).opcode;
if (opc == ByteCodes.idiv || opc == ByteCodes.imod
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/ConstFold.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/ConstFold.java Thu Oct 25 11:09:36 2012 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -31,7 +31,8 @@
import com.sun.tools.javac.code.Type.*;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
+
import static com.sun.tools.javac.jvm.ByteCodes.*;
/** Helper class for constant folding, used by the attribution phase.
@@ -176,19 +177,19 @@
case imod:
return syms.intType.constType(intValue(l) % intValue(r));
case iand:
- return (left.tag == BOOLEAN
+ return (left.hasTag(BOOLEAN)
? syms.booleanType : syms.intType)
.constType(intValue(l) & intValue(r));
case bool_and:
return syms.booleanType.constType(b2i((intValue(l) & intValue(r)) != 0));
case ior:
- return (left.tag == BOOLEAN
+ return (left.hasTag(BOOLEAN)
? syms.booleanType : syms.intType)
.constType(intValue(l) | intValue(r));
case bool_or:
return syms.booleanType.constType(b2i((intValue(l) | intValue(r)) != 0));
case ixor:
- return (left.tag == BOOLEAN
+ return (left.hasTag(BOOLEAN)
? syms.booleanType : syms.intType)
.constType(intValue(l) ^ intValue(r));
case ishl: case ishll:
@@ -326,7 +327,7 @@
/** Coerce constant type to target type.
* @param etype The source type of the coercion,
- * which is assumed to be a constant type compatble with
+ * which is assumed to be a constant type compatible with
* ttype.
* @param ttype The target type of the coercion.
*/
@@ -334,9 +335,9 @@
// WAS if (etype.baseType() == ttype.baseType())
if (etype.tsym.type == ttype.tsym.type)
return etype;
- if (etype.tag <= DOUBLE) {
+ if (etype.isNumeric()) {
Object n = etype.constValue();
- switch (ttype.tag) {
+ switch (ttype.getTag()) {
case BYTE:
return syms.byteType.constType(0 + (byte)intValue(n));
case CHAR:
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java Thu Oct 25 11:09:36 2012 -0700
@@ -44,7 +44,8 @@
import java.util.Set;
import java.util.WeakHashMap;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.DEFERRED;
+import static com.sun.tools.javac.code.TypeTag.NONE;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
/**
@@ -203,7 +204,7 @@
case SPECULATIVE:
Assert.check(mode == null ||
(mode == AttrMode.SPECULATIVE &&
- speculativeType(deferredAttrContext.msym, deferredAttrContext.phase).tag == NONE));
+ speculativeType(deferredAttrContext.msym, deferredAttrContext.phase).hasTag(NONE)));
JCTree speculativeTree = attribSpeculative(tree, env, resultInfo);
speculativeCache.put(deferredAttrContext.msym, speculativeTree, deferredAttrContext.phase);
return speculativeTree.type;
@@ -442,7 +443,7 @@
@Override
public Type apply(Type t) {
- if (t.tag != DEFERRED) {
+ if (!t.hasTag(DEFERRED)) {
return t.map(this);
} else {
DeferredType dt = (DeferredType)t;
@@ -479,7 +480,7 @@
@Override
protected Type typeOf(DeferredType dt) {
Type owntype = super.typeOf(dt);
- return owntype.tag == NONE ?
+ return owntype.hasTag(NONE) ?
recover(dt) : owntype;
}
@@ -516,7 +517,7 @@
*/
@SuppressWarnings("fallthrough")
List<Type> stuckVars(JCTree tree, ResultInfo resultInfo) {
- if (resultInfo.pt.tag == NONE || resultInfo.pt.isErroneous()) {
+ if (resultInfo.pt.hasTag(NONE) || resultInfo.pt.isErroneous()) {
return List.nil();
} else {
StuckChecker sc = new StuckChecker(resultInfo);
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Enter.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Enter.java Thu Oct 25 11:09:36 2012 -0700
@@ -49,7 +49,7 @@
* the symbol table. The pass consists of two phases, organized as
* follows:
*
- * <p>In the first phase, all class symbols are intered into their
+ * <p>In the first phase, all class symbols are entered into their
* enclosing scope, descending recursively down the tree for classes
* which are members of other classes. The class symbols are given a
* MemberEnter object as completer.
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java Thu Oct 25 11:09:36 2012 -0700
@@ -40,7 +40,8 @@
import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.code.Flags.BLOCK;
import static com.sun.tools.javac.code.Kinds.*;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
+import static com.sun.tools.javac.code.TypeTag.VOID;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
/** This pass implements dataflow analysis for Java programs though
@@ -473,7 +474,7 @@
alive = true;
scanStat(tree.body);
- if (alive && tree.sym.type.getReturnType().tag != VOID)
+ if (alive && !tree.sym.type.getReturnType().hasTag(VOID))
log.error(TreeInfo.diagEndPos(tree.body), "missing.ret.stmt");
List<PendingExit> exits = pendingExits.toList();
@@ -1976,8 +1977,8 @@
Bits uninitsBeforeElse = uninitsWhenFalse;
inits = initsWhenTrue;
uninits = uninitsWhenTrue;
- if (tree.truepart.type.tag == BOOLEAN &&
- tree.falsepart.type.tag == BOOLEAN) {
+ if (tree.truepart.type.hasTag(BOOLEAN) &&
+ tree.falsepart.type.hasTag(BOOLEAN)) {
// if b and c are boolean valued, then
// v is (un)assigned after a?b:c when true iff
// v is (un)assigned after b when true and
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Thu Oct 25 11:09:36 2012 -0700
@@ -42,7 +42,7 @@
import java.util.HashMap;
import java.util.Map;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.*;
/** Helper class for type parameter inference, used by the attribution phase.
*
@@ -145,7 +145,7 @@
private Filter<Type> boundFilter = new Filter<Type>() {
@Override
public boolean accepts(Type t) {
- return !t.isErroneous() && t.tag != BOT;
+ return !t.isErroneous() && !t.hasTag(BOT);
}
};
@@ -163,7 +163,7 @@
else {
that.inst = types.lub(lobounds);
}
- if (that.inst == null || that.inst.tag == ERROR)
+ if (that.inst == null || that.inst.hasTag(ERROR))
throw inferenceException
.setMessage("no.unique.minimal.instance.exists",
that.qtype, lobounds);
@@ -189,13 +189,13 @@
Attr.ResultInfo resultInfo,
Warner warn) throws InferenceException {
Type to = resultInfo.pt;
- if (to.tag == NONE || resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
- to = mtype.getReturnType().tag <= VOID ?
+ if (to.hasTag(NONE) || resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
+ to = mtype.getReturnType().isPrimitiveOrVoid() ?
mtype.getReturnType() : syms.objectType;
}
Type qtype1 = inferenceContext.asFree(mtype.getReturnType(), types);
if (!types.isSubtype(qtype1,
- qtype1.tag == UNDETVAR ? types.boxedTypeOrType(to) : to)) {
+ qtype1.hasTag(UNDETVAR) ? types.boxedTypeOrType(to) : to)) {
throw inferenceException
.setMessage("infer.no.conforming.instance.exists",
inferenceContext.restvars(), mtype.getReturnType(), to);
@@ -515,7 +515,7 @@
//for remaining uninferred type-vars in the functional interface type,
//simply replace the wildcards with its bound
for (Type t : formalInterface.getTypeArguments()) {
- if (actualTypeargs.head.tag == WILDCARD) {
+ if (actualTypeargs.head.hasTag(WILDCARD)) {
WildcardType wt = (WildcardType)actualTypeargs.head;
typeargs.append(wt.type);
} else {
@@ -592,7 +592,7 @@
public Type apply(Type t) {
t = types.erasure(super.apply(t));
- if (t.tag == BOT)
+ if (t.hasTag(BOT))
// nulls type as the marker type Null (which has no instances)
// infer as java.lang.Void for now
t = types.boxedClass(syms.voidType).type;
@@ -614,7 +614,7 @@
}
public Type apply(Type t) {
- if (t.tag == TYPEVAR) return new UndetVar((TypeVar)t, types, includeBounds);
+ if (t.hasTag(TYPEVAR)) return new UndetVar((TypeVar)t, types, includeBounds);
else return t.map(this);
}
};
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java Thu Oct 25 11:09:36 2012 -0700
@@ -45,7 +45,7 @@
import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.code.Flags.BLOCK;
import static com.sun.tools.javac.code.Kinds.*;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.*;
import static com.sun.tools.javac.jvm.ByteCodes.*;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
@@ -485,7 +485,7 @@
* @param value The literal's value.
*/
JCExpression makeLit(Type type, Object value) {
- return make.Literal(type.tag, value).setType(type.constType(value));
+ return make.Literal(type.getTag(), value).setType(type.constType(value));
}
/** Make an attributed tree representing null.
@@ -549,7 +549,7 @@
* reference type..
*/
JCExpression makeString(JCExpression tree) {
- if (tree.type.tag >= CLASS) {
+ if (!tree.type.isPrimitiveOrVoid()) {
return tree;
} else {
Symbol valueOfSym = lookupMethod(tree.pos(),
@@ -1405,7 +1405,7 @@
Name outerThisName(Type type, Symbol owner) {
Type t = type.getEnclosingType();
int nestingLevel = 0;
- while (t.tag == CLASS) {
+ while (t.hasTag(CLASS)) {
t = t.getEnclosingType();
nestingLevel++;
}
@@ -1529,7 +1529,7 @@
new VarSymbol(SYNTHETIC | FINAL,
makeSyntheticName(names.fromString("twrVar" +
depth), twrVars),
- (resource.type.tag == TypeTags.BOT) ?
+ (resource.type.hasTag(BOT)) ?
syms.autoCloseableType : resource.type,
currentMethodSym);
twrVars.enter(syntheticTwrVar);
@@ -1992,7 +1992,7 @@
}
private JCExpression classOfType(Type type, DiagnosticPosition pos) {
- switch (type.tag) {
+ switch (type.getTag()) {
case BYTE: case SHORT: case CHAR: case INT: case LONG: case FLOAT:
case DOUBLE: case BOOLEAN: case VOID:
// replace with <BoxedClass>.TYPE
@@ -2761,7 +2761,7 @@
}
//where
private JCTree convert(JCTree tree, Type pt) {
- if (tree.type == pt || tree.type.tag == TypeTags.BOT)
+ if (tree.type == pt || tree.type.hasTag(BOT))
return tree;
JCTree result = make_at(tree.pos()).TypeCast(make.Type(pt), (JCExpression)tree);
result.type = (tree.type.constValue() != null) ? cfolder.coerce(tree.type, pt)
@@ -2934,7 +2934,7 @@
return tree;
if (havePrimitive) {
Type unboxedTarget = types.unboxedType(type);
- if (unboxedTarget.tag != NONE) {
+ if (!unboxedTarget.hasTag(NONE)) {
if (!types.isSubtype(tree.type, unboxedTarget)) //e.g. Character c = 89;
tree.type = unboxedTarget.constType(tree.type.constValue());
return (T)boxPrimitive((JCExpression)tree, type);
@@ -2974,7 +2974,7 @@
/** Unbox an object to a primitive value. */
JCExpression unbox(JCExpression tree, Type primitive) {
Type unboxedType = types.unboxedType(tree.type);
- if (unboxedType.tag == NONE) {
+ if (unboxedType.hasTag(NONE)) {
unboxedType = primitive;
if (!unboxedType.isPrimitive())
throw new AssertionError(unboxedType);
@@ -3292,7 +3292,7 @@
iteratorTarget = types.erasure(iterableType.getTypeArguments().head);
Type eType = tree.expr.type;
tree.expr.type = types.erasure(eType);
- if (eType.tag == TYPEVAR && eType.getUpperBound().isCompound())
+ if (eType.hasTag(TYPEVAR) && eType.getUpperBound().isCompound())
tree.expr = make.TypeCast(types.erasure(iterableType), tree.expr);
Symbol iterator = lookupMethod(tree.expr.pos(),
names.iterator,
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java Thu Oct 25 11:09:36 2012 -0700
@@ -42,7 +42,9 @@
import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.code.Flags.ANNOTATION;
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.ERROR;
+import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
@@ -370,7 +372,7 @@
ListBuffer<Type> thrownbuf = new ListBuffer<Type>();
for (List<JCExpression> l = thrown; l.nonEmpty(); l = l.tail) {
Type exc = attr.attribType(l.head, env);
- if (exc.tag != TYPEVAR)
+ if (!exc.hasTag(TYPEVAR))
exc = chk.checkClassType(l.head.pos(), exc);
thrownbuf.append(exc);
}
@@ -921,7 +923,7 @@
}
for (JCExpression iface : interfaceTrees) {
Type i = attr.attribBase(iface, baseEnv, false, true, true);
- if (i.tag == CLASS) {
+ if (i.hasTag(CLASS)) {
interfaces.append(i);
if (all_interfaces != null) all_interfaces.append(i);
chk.checkNotRepeated(iface.pos(), types.erasure(i), interfaceSet);
@@ -1006,7 +1008,7 @@
new VarSymbol(FINAL | HASINIT, names._this, c.type, c);
thisSym.pos = Position.FIRSTPOS;
env.info.scope.enter(thisSym);
- if (ct.supertype_field.tag == CLASS) {
+ if (ct.supertype_field.hasTag(CLASS)) {
VarSymbol superSym =
new VarSymbol(FINAL | HASINIT, names._super,
ct.supertype_field, c);
@@ -1094,7 +1096,7 @@
}
Type modelMissingTypes(Type t, final JCExpression tree, final boolean interfaceExpected) {
- if (t.tag != ERROR)
+ if (!t.hasTag(ERROR))
return t;
return new ErrorType(((ErrorType) t).getOriginalType(), t.tsym) {
@@ -1139,7 +1141,7 @@
@Override
public void visitIdent(JCIdent tree) {
- if (tree.type.tag != ERROR) {
+ if (!tree.type.hasTag(ERROR)) {
result = tree.type;
} else {
result = synthesizeClass(tree.name, syms.unnamedPackage).type;
@@ -1148,7 +1150,7 @@
@Override
public void visitSelect(JCFieldAccess tree) {
- if (tree.type.tag != ERROR) {
+ if (!tree.type.hasTag(ERROR)) {
result = tree.type;
} else {
Type selectedType;
@@ -1166,7 +1168,7 @@
@Override
public void visitTypeApply(JCTypeApply tree) {
- if (tree.type.tag != ERROR) {
+ if (!tree.type.hasTag(ERROR)) {
result = tree.type;
} else {
ClassType clazzType = (ClassType) visit(tree.clazz);
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Thu Oct 25 11:09:36 2012 -0700
@@ -59,7 +59,7 @@
import static com.sun.tools.javac.code.Flags.BLOCK;
import static com.sun.tools.javac.code.Kinds.*;
import static com.sun.tools.javac.code.Kinds.ERRONEOUS;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.*;
import static com.sun.tools.javac.comp.Resolve.MethodResolutionPhase.*;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
@@ -228,7 +228,7 @@
JCDiagnostic getVerboseApplicableCandidateDiag(int pos, Symbol sym, Type inst) {
JCDiagnostic subDiag = null;
- if (sym.type.tag == FORALL) {
+ if (sym.type.hasTag(FORALL)) {
subDiag = diags.fragment("partial.inst.sig", inst);
}
@@ -331,7 +331,7 @@
}
boolean isAccessible(Env<AttrContext> env, Type t, boolean checkInner) {
- return (t.tag == ARRAY)
+ return (t.hasTag(ARRAY))
? isAccessible(env, types.elemtype(t))
: isAccessible(env, t.tsym, checkInner);
}
@@ -467,10 +467,10 @@
// need to inferred.
List<Type> tvars = List.nil();
if (typeargtypes == null) typeargtypes = List.nil();
- if (mt.tag != FORALL && typeargtypes.nonEmpty()) {
+ if (!mt.hasTag(FORALL) && typeargtypes.nonEmpty()) {
// This is not a polymorphic method, but typeargs are supplied
// which is fine, see JLS 15.12.2.1
- } else if (mt.tag == FORALL && typeargtypes.nonEmpty()) {
+ } else if (mt.hasTag(FORALL) && typeargtypes.nonEmpty()) {
ForAll pmt = (ForAll) mt;
if (typeargtypes.length() != pmt.tvars.length())
throw inapplicableMethodException.setMessage("arg.length.mismatch"); // not enough args
@@ -487,7 +487,7 @@
actuals = actuals.tail;
}
mt = types.subst(pmt.qtype, pmt.tvars, typeargtypes);
- } else if (mt.tag == FORALL) {
+ } else if (mt.hasTag(FORALL)) {
ForAll pmt = (ForAll) mt;
List<Type> tvars1 = types.newInstances(pmt.tvars);
tvars = tvars.appendList(tvars1);
@@ -499,7 +499,7 @@
for (List<Type> l = argtypes;
l.tail != null/*inlined: l.nonEmpty()*/ && !instNeeded;
l = l.tail) {
- if (l.head.tag == FORALL) instNeeded = true;
+ if (l.head.hasTag(FORALL)) instNeeded = true;
}
if (instNeeded)
@@ -807,7 +807,7 @@
@Override
protected Type check(DiagnosticPosition pos, Type found) {
- if (found.tag == DEFERRED) {
+ if (found.hasTag(DEFERRED)) {
DeferredType dt = (DeferredType)found;
return dt.check(this);
} else {
@@ -875,7 +875,7 @@
Type site,
Name name,
TypeSymbol c) {
- while (c.type.tag == TYPEVAR)
+ while (c.type.hasTag(TYPEVAR))
c = c.type.getUpperBound().tsym;
Symbol bestSoFar = varNotFound;
Symbol sym;
@@ -888,7 +888,7 @@
e = e.next();
}
Type st = types.supertype(c.type);
- if (st != null && (st.tag == CLASS || st.tag == TYPEVAR)) {
+ if (st != null && (st.hasTag(CLASS) || st.hasTag(TYPEVAR))) {
sym = findField(env, site, name, st.tsym);
if (sym.kind < bestSoFar.kind) bestSoFar = sym;
}
@@ -1184,7 +1184,7 @@
lastFormal2 : formals2.head;
//is this a structural actual argument?
- boolean isStructuralPoly = actual.tag == DEFERRED &&
+ boolean isStructuralPoly = actual.hasTag(DEFERRED) &&
(((DeferredType)actual).tree.hasTag(LAMBDA) ||
((DeferredType)actual).tree.hasTag(REFERENCE));
@@ -1301,7 +1301,7 @@
Type rt1 = mt1.getReturnType();
Type rt2 = mt2.getReturnType();
- if (mt1.tag == FORALL && mt2.tag == FORALL) {
+ if (mt1.hasTag(FORALL) && mt2.hasTag(FORALL)) {
//if both are generic methods, adjust return type ahead of subtyping check
rt1 = types.subst(rt1, mt1.getTypeArguments(), mt2.getTypeArguments());
}
@@ -1448,11 +1448,11 @@
}
TypeSymbol symbolFor(Type t) {
- if (t.tag != CLASS &&
- t.tag != TYPEVAR) {
+ if (!t.hasTag(CLASS) &&
+ !t.hasTag(TYPEVAR)) {
return null;
}
- while (t.tag == TYPEVAR)
+ while (t.hasTag(TYPEVAR))
t = t.getUpperBound();
if (seen.contains(t.tsym)) {
//degenerate case in which we have a circular
@@ -1610,7 +1610,7 @@
e = e.next();
}
Type st = types.supertype(c.type);
- if (st != null && st.tag == CLASS) {
+ if (st != null && st.hasTag(CLASS)) {
sym = findMemberType(env, site, name, st.tsym);
if (sym.kind < bestSoFar.kind) bestSoFar = sym;
}
@@ -1660,7 +1660,7 @@
e = e.next()) {
if (e.sym.kind == TYP) {
if (staticOnly &&
- e.sym.type.tag == TYPEVAR &&
+ e.sym.type.hasTag(TYPEVAR) &&
e.sym.owner.kind == TYP) return new StaticError(e.sym);
return e.sym;
}
@@ -1669,8 +1669,8 @@
sym = findMemberType(env1, env1.enclClass.sym.type, name,
env1.enclClass.sym);
if (staticOnly && sym.kind == TYP &&
- sym.type.tag == CLASS &&
- sym.type.getEnclosingType().tag == CLASS &&
+ sym.type.hasTag(CLASS) &&
+ sym.type.getEnclosingType().hasTag(CLASS) &&
env1.enclClass.sym.type.isParameterized() &&
sym.type.getEnclosingType().isParameterized())
return new StaticError(sym);
@@ -1906,7 +1906,7 @@
//method symbol that can be used for lookups in the speculative cache,
//causing problems in Attr.checkId()
for (Type t : argtypes) {
- if (t.tag == DEFERRED) {
+ if (t.hasTag(DEFERRED)) {
DeferredType dt = (DeferredType)t;
dt.speculativeCache.dupAllTo(msym, accessedSym);
}
@@ -1955,7 +1955,7 @@
}
public void printscopes(Type t) {
- while (t.tag == CLASS) {
+ while (t.hasTag(CLASS)) {
printscopes(t.tsym.members());
t = types.supertype(t);
}
@@ -2259,7 +2259,7 @@
//- System.out.println(" e " + e.sym);
if (sym.kind == MTH &&
(sym.flags_field & SYNTHETIC) == 0) {
- List<Type> oldParams = e.sym.type.tag == FORALL ?
+ List<Type> oldParams = e.sym.type.hasTag(FORALL) ?
((ForAll)sym.type).tvars :
List.<Type>nil();
Type constrType = new ForAll(site.tsym.type.getTypeArguments().appendList(oldParams),
@@ -2565,7 +2565,7 @@
findMethod(env, site, name, argtypes, typeargtypes,
phase.isBoxingRequired(), phase.isVarargsRequired(), syms.operatorNames.contains(name));
return sym.kind != MTH ||
- site.getEnclosingType().tag == NONE ||
+ site.getEnclosingType().hasTag(NONE) ||
hasEnclosingInstance(env, site) ?
sym : new InvalidSymbolError(Kinds.MISSING_ENCL, sym, null) {
@Override
@@ -2578,7 +2578,7 @@
@Override
ReferenceKind referenceKind(Symbol sym) {
- return site.getEnclosingType().tag == NONE ?
+ return site.getEnclosingType().hasTag(NONE) ?
ReferenceKind.TOPLEVEL : ReferenceKind.IMPLICIT_INNER;
}
}
@@ -2847,7 +2847,7 @@
} else {
ListBuffer<Object> diagArgs = ListBuffer.lb();
for (Type t : argtypes) {
- if (t.tag == DEFERRED) {
+ if (t.hasTag(DEFERRED)) {
diagArgs.append(((DeferredAttr.DeferredType)t).tree);
} else {
diagArgs.append(t);
@@ -3222,7 +3222,7 @@
Name name,
List<Type> argtypes,
List<Type> typeargtypes) {
- if (sym.owner.type.tag == ERROR)
+ if (sym.owner.type.hasTag(ERROR))
return null;
if (sym.name == names.init && sym.owner != site.tsym) {
@@ -3267,7 +3267,7 @@
Name name,
List<Type> argtypes,
List<Type> typeargtypes) {
- Symbol errSym = ((sym.kind == TYP && sym.type.tag == CLASS)
+ Symbol errSym = ((sym.kind == TYP && sym.type.hasTag(CLASS))
? types.erasure(sym.type).tsym
: sym);
return diags.create(dkind, log.currentSource(), pos,
--- a/langtools/src/share/classes/com/sun/tools/javac/comp/TransTypes.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/comp/TransTypes.java Thu Oct 25 11:09:36 2012 -0700
@@ -37,7 +37,9 @@
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.TYPEVAR;
+import static com.sun.tools.javac.code.TypeTag.VOID;
/** This pass translates Generic Java to conventional Java.
*
@@ -155,7 +157,7 @@
*/
JCExpression retype(JCExpression tree, Type erasedType, Type target) {
// System.err.println("retype " + tree + " to " + erasedType);//DEBUG
- if (erasedType.tag > lastBaseTag) {
+ if (!erasedType.isPrimitive()) {
if (target != null && target.isPrimitive())
target = erasure(tree.type);
tree.type = erasedType;
@@ -245,7 +247,7 @@
make.Select(receiver, impl).setType(calltype),
translateArgs(make.Idents(md.params), origErasure.getParameterTypes(), null))
.setType(calltype);
- JCStatement stat = (origErasure.getReturnType().tag == VOID)
+ JCStatement stat = (origErasure.getReturnType().hasTag(VOID))
? make.Exec(call)
: make.Return(coerce(call, bridgeType.getReturnType()));
md.body = make.Block(0, List.of(stat));
@@ -400,7 +402,7 @@
*/
void addBridges(DiagnosticPosition pos, ClassSymbol origin, ListBuffer<JCTree> bridges) {
Type st = types.supertype(origin.type);
- while (st.tag == CLASS) {
+ while (st.hasTag(CLASS)) {
// if (isSpecialization(st))
addBridges(pos, st.tsym, origin, bridges);
st = types.supertype(st);
@@ -701,7 +703,7 @@
Type et = tree.sym.erasure(types);
// Map type variables to their bounds.
- if (tree.sym.kind == TYP && tree.sym.type.tag == TYPEVAR) {
+ if (tree.sym.kind == TYP && tree.sym.type.hasTag(TYPEVAR)) {
result = make.at(tree.pos).Type(et);
} else
// Map constants expressions to themselves.
@@ -720,7 +722,7 @@
public void visitSelect(JCFieldAccess tree) {
Type t = tree.selected.type;
- while (t.tag == TYPEVAR)
+ while (t.hasTag(TYPEVAR))
t = t.getUpperBound();
if (t.isCompound()) {
if ((tree.sym.flags() & IPROXY) != 0) {
@@ -844,7 +846,7 @@
translateArgs(make.Idents(md.params),
implErasure.getParameterTypes(), null))
.setType(calltype);
- JCStatement stat = (member.getReturnType().tag == VOID)
+ JCStatement stat = (member.getReturnType().hasTag(VOID))
? make.Exec(call)
: make.Return(coerce(call, member.erasure(types).getReturnType()));
md.body = make.Block(0, List.of(stat));
@@ -862,7 +864,7 @@
Type st = types.supertype(c.type);
// process superclass before derived
- if (st.tag == CLASS)
+ if (st.hasTag(CLASS))
translateClass((ClassSymbol)st.tsym);
Env<AttrContext> myEnv = enter.typeEnvs.remove(c);
--- a/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java Thu Oct 25 11:09:36 2012 -0700
@@ -55,7 +55,7 @@
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.jvm.ClassFile.*;
import static com.sun.tools.javac.jvm.ClassFile.Version.*;
@@ -1870,7 +1870,7 @@
* `typevars'.
*/
protected void enterTypevars(Type t) {
- if (t.getEnclosingType() != null && t.getEnclosingType().tag == CLASS)
+ if (t.getEnclosingType() != null && t.getEnclosingType().hasTag(CLASS))
enterTypevars(t.getEnclosingType());
for (List<Type> xs = t.getTypeArguments(); xs.nonEmpty(); xs = xs.tail)
typevars.enter(xs.head.tsym);
@@ -1895,7 +1895,7 @@
// prepare type variable table
typevars = typevars.dup(currentOwner);
- if (ct.getEnclosingType().tag == CLASS)
+ if (ct.getEnclosingType().hasTag(CLASS))
enterTypevars(ct.getEnclosingType());
// read flags, or skip if this is an inner class
--- a/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Thu Oct 25 11:09:36 2012 -0700
@@ -45,7 +45,7 @@
import static com.sun.tools.javac.code.BoundKind.*;
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.*;
import static com.sun.tools.javac.jvm.UninitializedType.*;
import static com.sun.tools.javac.main.Option.*;
import static javax.tools.StandardLocation.CLASS_OUTPUT;
@@ -274,7 +274,7 @@
/** Assemble signature of given type in string buffer.
*/
void assembleSig(Type type) {
- switch (type.tag) {
+ switch (type.getTag()) {
case BYTE:
sigbuf.appendByte('B');
break;
@@ -361,13 +361,13 @@
assembleSig(types.erasure(((UninitializedType)type).qtype));
break;
default:
- throw new AssertionError("typeSig " + type.tag);
+ throw new AssertionError("typeSig " + type.getTag());
}
}
boolean hasTypeVar(List<Type> l) {
while (l.nonEmpty()) {
- if (l.head.tag == TypeTags.TYPEVAR) return true;
+ if (l.head.hasTag(TYPEVAR)) return true;
l = l.tail;
}
return false;
@@ -439,9 +439,9 @@
* external representation.
*/
public Name xClassName(Type t) {
- if (t.tag == CLASS) {
+ if (t.hasTag(CLASS)) {
return names.fromUtf(externalize(t.tsym.flatName()));
- } else if (t.tag == ARRAY) {
+ } else if (t.hasTag(ARRAY)) {
return typeSig(types.erasure(t));
} else {
throw new AssertionError("xClassName");
@@ -521,7 +521,7 @@
ClassSymbol c = (ClassSymbol)value;
if (c.owner.kind == TYP) pool.put(c.owner);
poolbuf.appendByte(CONSTANT_Class);
- if (c.type.tag == ARRAY) {
+ if (c.type.hasTag(ARRAY)) {
poolbuf.appendChar(pool.put(typeSig(c.type)));
} else {
poolbuf.appendChar(pool.put(names.fromUtf(externalize(c.flatname))));
@@ -555,7 +555,7 @@
poolbuf.appendChar(pool.put(typeSig(mtype)));
} else if (value instanceof Type) {
Type type = (Type)value;
- if (type.tag == CLASS) enterInner((ClassSymbol)type.tsym);
+ if (type.hasTag(CLASS)) enterInner((ClassSymbol)type.tsym);
poolbuf.appendByte(CONSTANT_Class);
poolbuf.appendChar(pool.put(xClassName(type)));
} else if (value instanceof Pool.MethodHandle) {
@@ -815,7 +815,7 @@
class AttributeWriter implements Attribute.Visitor {
public void visitConstant(Attribute.Constant _value) {
Object value = _value.value;
- switch (_value.type.tag) {
+ switch (_value.type.getTag()) {
case BYTE:
databuf.appendByte('B');
break;
@@ -901,7 +901,7 @@
System.err.println("error: " + c + ": " + ex.getMessage());
throw ex;
}
- if (c.type.tag != CLASS) return; // arrays
+ if (!c.type.hasTag(CLASS)) return; // arrays
if (pool != null && // pool might be null if called from xClassName
c.owner.enclClass() != null &&
(innerClasses == null || !innerClasses.contains(c))) {
@@ -1207,7 +1207,7 @@
if (debugstackmap) System.out.print("empty");
databuf.appendByte(0);
}
- else switch(t.tag) {
+ else switch(t.getTag()) {
case BYTE:
case CHAR:
case SHORT:
@@ -1430,7 +1430,7 @@
}
static boolean isInt(Type t) {
- return (t.tag < TypeTags.INT || t.tag == TypeTags.BOOLEAN);
+ return (t.getTag().isStrictSubRangeOf(INT) || t.hasTag(BOOLEAN));
}
static boolean isSameType(Type t1, Type t2, Types types) {
@@ -1439,15 +1439,15 @@
if (isInt(t1) && isInt(t2)) { return true; }
- if (t1.tag == UNINITIALIZED_THIS) {
- return t2.tag == UNINITIALIZED_THIS;
- } else if (t1.tag == UNINITIALIZED_OBJECT) {
- if (t2.tag == UNINITIALIZED_OBJECT) {
+ if (t1.hasTag(UNINITIALIZED_THIS)) {
+ return t2.hasTag(UNINITIALIZED_THIS);
+ } else if (t1.hasTag(UNINITIALIZED_OBJECT)) {
+ if (t2.hasTag(UNINITIALIZED_OBJECT)) {
return ((UninitializedType)t1).offset == ((UninitializedType)t2).offset;
} else {
return false;
}
- } else if (t2.tag == UNINITIALIZED_THIS || t2.tag == UNINITIALIZED_OBJECT) {
+ } else if (t2.hasTag(UNINITIALIZED_THIS) || t2.hasTag(UNINITIALIZED_OBJECT)) {
return false;
}
@@ -1554,7 +1554,7 @@
databuf.appendChar(flags);
databuf.appendChar(pool.put(c));
- databuf.appendChar(supertype.tag == CLASS ? pool.put(supertype.tsym) : 0);
+ databuf.appendChar(supertype.hasTag(CLASS) ? pool.put(supertype.tsym) : 0);
databuf.appendChar(interfaces.length());
for (List<Type> l = interfaces; l.nonEmpty(); l = l.tail)
databuf.appendChar(pool.put(l.head.tsym));
--- a/langtools/src/share/classes/com/sun/tools/javac/jvm/Code.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/Code.java Thu Oct 25 11:09:36 2012 -0700
@@ -30,7 +30,8 @@
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.BOT;
+import static com.sun.tools.javac.code.TypeTag.INT;
import static com.sun.tools.javac.jvm.ByteCodes.*;
import static com.sun.tools.javac.jvm.UninitializedType.*;
import static com.sun.tools.javac.jvm.ClassWriter.StackMapTableFrame;
@@ -224,7 +225,7 @@
* JVM architecture).
*/
public static int typecode(Type type) {
- switch (type.tag) {
+ switch (type.getTag()) {
case BYTE: return BYTEcode;
case SHORT: return SHORTcode;
case CHAR: return CHARcode;
@@ -242,7 +243,7 @@
case UNINITIALIZED_THIS:
case UNINITIALIZED_OBJECT:
return OBJECTcode;
- default: throw new AssertionError("typecode " + type.tag);
+ default: throw new AssertionError("typecode " + type.getTag());
}
}
@@ -281,7 +282,7 @@
/** Given a type, return its code for allocating arrays of that type.
*/
public static int arraycode(Type type) {
- switch (type.tag) {
+ switch (type.getTag()) {
case BYTE: return 8;
case BOOLEAN: return 4;
case SHORT: return 9;
@@ -477,7 +478,7 @@
state.pop(1);
//sometimes 'null type' is treated as a one-dimensional array type
//see Gen.visitLiteral - we should handle this case accordingly
- Type stackType = a.tag == BOT ?
+ Type stackType = a.hasTag(BOT) ?
syms.objectType :
types.erasure(types.elemtype(a));
state.push(stackType); }
@@ -1656,13 +1657,13 @@
void push(Type t) {
if (debugCode) System.err.println(" pushing " + t);
- switch (t.tag) {
- case TypeTags.VOID:
+ switch (t.getTag()) {
+ case VOID:
return;
- case TypeTags.BYTE:
- case TypeTags.CHAR:
- case TypeTags.SHORT:
- case TypeTags.BOOLEAN:
+ case BYTE:
+ case CHAR:
+ case SHORT:
+ case BOOLEAN:
t = syms.intType;
break;
default:
@@ -1722,7 +1723,7 @@
* of its current type. */
void forceStackTop(Type t) {
if (!alive) return;
- switch (t.tag) {
+ switch (t.getTag()) {
case CLASS:
case ARRAY:
int width = width(t);
@@ -1824,7 +1825,7 @@
}
}
- static Type jsrReturnValue = new Type(TypeTags.INT, null);
+ static Type jsrReturnValue = new Type(INT, null);
/* **************************************************************************
--- a/langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java Thu Oct 25 11:09:36 2012 -0700
@@ -42,7 +42,7 @@
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.*;
import static com.sun.tools.javac.jvm.ByteCodes.*;
import static com.sun.tools.javac.jvm.CRTFlags.*;
import static com.sun.tools.javac.main.Option.*;
@@ -258,7 +258,7 @@
*/
Symbol binaryQualifier(Symbol sym, Type site) {
- if (site.tag == ARRAY) {
+ if (site.hasTag(ARRAY)) {
if (sym == syms.lengthVar ||
sym.owner != syms.arrayClass)
return sym;
@@ -305,13 +305,13 @@
*/
int makeRef(DiagnosticPosition pos, Type type) {
checkDimension(pos, type);
- return pool.put(type.tag == CLASS ? (Object)type.tsym : (Object)type);
+ return pool.put(type.hasTag(CLASS) ? (Object)type.tsym : (Object)type);
}
/** Check if the given type is an array with too many dimensions.
*/
private void checkDimension(DiagnosticPosition pos, Type t) {
- switch (t.tag) {
+ switch (t.getTag()) {
case METHOD:
checkDimension(pos, t.getReturnType());
for (List<Type> args = t.getParameterTypes(); args.nonEmpty(); args = args.tail)
@@ -922,7 +922,7 @@
if (code.isAlive()) {
code.statBegin(TreeInfo.endPos(tree.body));
if (env.enclMethod == null ||
- env.enclMethod.sym.type.getReturnType().tag == VOID) {
+ env.enclMethod.sym.type.getReturnType().hasTag(VOID)) {
code.emitop0(return_);
} else {
// sometime dead code seems alive (4415991);
@@ -1110,7 +1110,7 @@
public void visitSwitch(JCSwitch tree) {
int limit = code.nextreg;
- Assert.check(tree.selector.type.tag != CLASS);
+ Assert.check(!tree.selector.type.hasTag(CLASS));
int startpcCrt = genCrt ? code.curPc() : 0;
Item sel = genExpr(tree.selector, syms.intType);
List<JCCase> cases = tree.cases;
@@ -1817,8 +1817,8 @@
// proceeding further.
if ((tree.hasTag(PLUS_ASG) || tree.hasTag(MINUS_ASG)) &&
l instanceof LocalItem &&
- tree.lhs.type.tag <= INT &&
- tree.rhs.type.tag <= INT &&
+ tree.lhs.type.getTag().isSubRangeOf(INT) &&
+ tree.rhs.type.getTag().isSubRangeOf(INT) &&
tree.rhs.type.constValue() != null) {
int ival = ((Number) tree.rhs.type.constValue()).intValue();
if (tree.hasTag(MINUS_ASG)) ival = -ival;
@@ -1969,7 +1969,7 @@
*/
void appendString(JCTree tree) {
Type t = tree.type.baseType();
- if (t.tag > lastBaseTag && t.tsym != syms.stringType.tsym) {
+ if (!t.isPrimitive() && t.tsym != syms.stringType.tsym) {
t = syms.objectType;
}
items.makeMemberItem(getStringBufferAppend(tree, t), false).invoke();
@@ -2067,7 +2067,7 @@
// which is not statically a supertype of the expression's type.
// For basic types, the coerce(...) in genExpr(...) will do
// the conversion.
- if (tree.clazz.type.tag > lastBaseTag &&
+ if (!tree.clazz.type.isPrimitive() &&
types.asSuper(tree.expr.type, tree.clazz.type.tsym) == null) {
code.emitop2(checkcast, makeRef(tree.pos(), tree.clazz.type));
}
@@ -2185,7 +2185,7 @@
}
public void visitLiteral(JCLiteral tree) {
- if (tree.type.tag == TypeTags.BOT) {
+ if (tree.type.hasTag(BOT)) {
code.emitop0(aconst_null);
if (types.dimensions(pt) > 1) {
code.emitop2(checkcast, makeRef(tree.pos(), pt));
--- a/langtools/src/share/classes/com/sun/tools/javac/jvm/UninitializedType.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/UninitializedType.java Thu Oct 25 11:09:36 2012 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,6 +27,8 @@
import com.sun.tools.javac.code.*;
+import static com.sun.tools.javac.code.TypeTag.UNINITIALIZED_OBJECT;
+import static com.sun.tools.javac.code.TypeTag.UNINITIALIZED_THIS;
/** These pseudo-types appear in the generated verifier tables to
* indicate objects that have been allocated but not yet constructed.
@@ -37,8 +39,6 @@
* deletion without notice.</b>
*/
class UninitializedType extends Type.DelegatedType {
- public static final int UNINITIALIZED_THIS = TypeTags.TypeTagCount;
- public static final int UNINITIALIZED_OBJECT = UNINITIALIZED_THIS + 1;
public static UninitializedType uninitializedThis(Type qtype) {
return new UninitializedType(UNINITIALIZED_THIS, qtype, -1);
@@ -49,7 +49,7 @@
}
public final int offset; // PC where allocation took place
- private UninitializedType(int tag, Type qtype, int offset) {
+ private UninitializedType(TypeTag tag, Type qtype, int offset) {
super(tag, qtype);
this.offset = offset;
}
--- a/langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java Thu Oct 25 11:09:36 2012 -0700
@@ -63,6 +63,7 @@
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.Log.WriterKind;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
import static com.sun.tools.javac.main.Option.*;
import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;
import static com.sun.tools.javac.util.ListBuffer.lb;
@@ -1349,7 +1350,7 @@
@Override
public void visitClassDef(JCClassDecl node) {
Type st = types.supertype(node.sym.type);
- if (st.tag == TypeTags.CLASS) {
+ if (st.hasTag(CLASS)) {
ClassSymbol c = st.tsym.outermostClass();
Env<AttrContext> stEnv = enter.getEnv(c);
if (stEnv != null && env != stEnv) {
--- a/langtools/src/share/classes/com/sun/tools/javac/model/JavacElements.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/model/JavacElements.java Thu Oct 25 11:09:36 2012 -0700
@@ -38,7 +38,7 @@
import com.sun.tools.javac.code.*;
import com.sun.tools.javac.code.Symbol.*;
-import com.sun.tools.javac.code.TypeTags;
+import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.comp.AttrContext;
import com.sun.tools.javac.comp.Enter;
import com.sun.tools.javac.comp.Env;
@@ -50,6 +50,7 @@
import com.sun.tools.javac.tree.TreeScanner;
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.Name;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
/**
@@ -124,7 +125,7 @@
if (result != null || !inherited)
break;
Type sup = annotated.getSuperclass();
- if (sup.tag != TypeTags.CLASS || sup.isErroneous())
+ if (!sup.hasTag(CLASS) || sup.isErroneous())
break;
annotated = (ClassSymbol) sup.tsym;
}
@@ -444,7 +445,7 @@
List<Attribute.Compound> annos = sym.getAnnotationMirrors();
while (sym.getKind() == ElementKind.CLASS) {
Type sup = ((ClassSymbol) sym).getSuperclass();
- if (sup.tag != TypeTags.CLASS || sup.isErroneous() ||
+ if (!sup.hasTag(CLASS) || sup.isErroneous() ||
sup.tsym == syms.objectType.tsym) {
break;
}
--- a/langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java Thu Oct 25 11:09:36 2012 -0700
@@ -560,7 +560,7 @@
case INTLITERAL:
try {
t = F.at(pos).Literal(
- TypeTags.INT,
+ TypeTag.INT,
Convert.string2int(strval(prefix), token.radix()));
} catch (NumberFormatException ex) {
error(token.pos, "int.number.too.large", strval(prefix));
@@ -569,7 +569,7 @@
case LONGLITERAL:
try {
t = F.at(pos).Literal(
- TypeTags.LONG,
+ TypeTag.LONG,
new Long(Convert.string2long(strval(prefix), token.radix())));
} catch (NumberFormatException ex) {
error(token.pos, "int.number.too.large", strval(prefix));
@@ -591,7 +591,7 @@
else if (n.floatValue() == Float.POSITIVE_INFINITY)
error(token.pos, "fp.number.too.large");
else
- t = F.at(pos).Literal(TypeTags.FLOAT, n);
+ t = F.at(pos).Literal(TypeTag.FLOAT, n);
break;
}
case DOUBLELITERAL: {
@@ -610,27 +610,27 @@
else if (n.doubleValue() == Double.POSITIVE_INFINITY)
error(token.pos, "fp.number.too.large");
else
- t = F.at(pos).Literal(TypeTags.DOUBLE, n);
+ t = F.at(pos).Literal(TypeTag.DOUBLE, n);
break;
}
case CHARLITERAL:
t = F.at(pos).Literal(
- TypeTags.CHAR,
+ TypeTag.CHAR,
token.stringVal().charAt(0) + 0);
break;
case STRINGLITERAL:
t = F.at(pos).Literal(
- TypeTags.CLASS,
+ TypeTag.CLASS,
token.stringVal());
break;
case TRUE: case FALSE:
t = F.at(pos).Literal(
- TypeTags.BOOLEAN,
+ TypeTag.BOOLEAN,
(token.kind == TRUE ? 1 : 0));
break;
case NULL:
t = F.at(pos).Literal(
- TypeTags.BOT,
+ TypeTag.BOT,
null);
break;
default:
@@ -814,7 +814,7 @@
if (t.hasTag(JCTree.Tag.PLUS)) {
StringBuilder buf = foldStrings(t);
if (buf != null) {
- t = toP(F.at(startPos).Literal(TypeTags.CLASS, buf.toString()));
+ t = toP(F.at(startPos).Literal(TypeTag.CLASS, buf.toString()));
}
}
@@ -846,7 +846,7 @@
while (true) {
if (tree.hasTag(LITERAL)) {
JCLiteral lit = (JCLiteral) tree;
- if (lit.typetag == TypeTags.CLASS) {
+ if (lit.typetag == TypeTag.CLASS) {
StringBuilder sbuf =
new StringBuilder((String)lit.value);
while (buf.nonEmpty()) {
@@ -859,7 +859,7 @@
JCBinary op = (JCBinary)tree;
if (op.rhs.hasTag(LITERAL)) {
JCLiteral lit = (JCLiteral) op.rhs;
- if (lit.typetag == TypeTags.CLASS) {
+ if (lit.typetag == TypeTag.CLASS) {
buf = buf.prepend((String) lit.value);
tree = op.lhs;
continue;
@@ -1211,7 +1211,7 @@
if ((mode & EXPR) != 0) {
nextToken();
if (token.kind == DOT) {
- JCPrimitiveTypeTree ti = toP(F.at(pos).TypeIdent(TypeTags.VOID));
+ JCPrimitiveTypeTree ti = toP(F.at(pos).TypeIdent(TypeTag.VOID));
t = bracketsSuffix(ti);
} else {
return illegal(pos);
@@ -1220,7 +1220,7 @@
// Support the corner case of myMethodHandle.<void>invoke() by passing
// a void type (like other primitive types) to the next phase.
// The error will be reported in Attr.attribTypes or Attr.visitApply.
- JCPrimitiveTypeTree ti = to(F.at(pos).TypeIdent(TypeTags.VOID));
+ JCPrimitiveTypeTree ti = to(F.at(pos).TypeIdent(TypeTag.VOID));
nextToken();
return ti;
//return illegal();
@@ -2920,7 +2920,7 @@
JCExpression type;
boolean isVoid = token.kind == VOID;
if (isVoid) {
- type = to(F.at(pos).TypeIdent(TypeTags.VOID));
+ type = to(F.at(pos).TypeIdent(TypeTag.VOID));
nextToken();
} else {
type = parseType();
@@ -3283,28 +3283,28 @@
}
/** Return type tag of basic type represented by token,
- * -1 if token is not a basic type identifier.
+ * NONE if token is not a basic type identifier.
*/
- static int typetag(TokenKind token) {
+ static TypeTag typetag(TokenKind token) {
switch (token) {
case BYTE:
- return TypeTags.BYTE;
+ return TypeTag.BYTE;
case CHAR:
- return TypeTags.CHAR;
+ return TypeTag.CHAR;
case SHORT:
- return TypeTags.SHORT;
+ return TypeTag.SHORT;
case INT:
- return TypeTags.INT;
+ return TypeTag.INT;
case LONG:
- return TypeTags.LONG;
+ return TypeTag.LONG;
case FLOAT:
- return TypeTags.FLOAT;
+ return TypeTag.FLOAT;
case DOUBLE:
- return TypeTags.DOUBLE;
+ return TypeTag.DOUBLE;
case BOOLEAN:
- return TypeTags.BOOLEAN;
+ return TypeTag.BOOLEAN;
default:
- return -1;
+ return TypeTag.NONE;
}
}
--- a/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java Thu Oct 25 11:09:36 2012 -0700
@@ -81,7 +81,7 @@
public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
/* Tree tag values, identifying kinds of trees */
- public enum Tag{
+ public enum Tag {
/** For methods that return an invalid tag if a given condition is not met
*/
NO_TAG,
@@ -1912,10 +1912,10 @@
* A constant value given literally.
*/
public static class JCLiteral extends JCExpression implements LiteralTree {
- public int typetag;
+ public TypeTag typetag;
/** value representation */
public Object value;
- protected JCLiteral(int typetag, Object value) {
+ protected JCLiteral(TypeTag typetag, Object value) {
this.typetag = typetag;
this.value = value;
}
@@ -1923,33 +1923,15 @@
public void accept(Visitor v) { v.visitLiteral(this); }
public Kind getKind() {
- switch (typetag) {
- case TypeTags.INT:
- return Kind.INT_LITERAL;
- case TypeTags.LONG:
- return Kind.LONG_LITERAL;
- case TypeTags.FLOAT:
- return Kind.FLOAT_LITERAL;
- case TypeTags.DOUBLE:
- return Kind.DOUBLE_LITERAL;
- case TypeTags.BOOLEAN:
- return Kind.BOOLEAN_LITERAL;
- case TypeTags.CHAR:
- return Kind.CHAR_LITERAL;
- case TypeTags.CLASS:
- return Kind.STRING_LITERAL;
- case TypeTags.BOT:
- return Kind.NULL_LITERAL;
- default:
- throw new AssertionError("unknown literal kind " + this);
- }
+ return typetag.getKindLiteral();
}
+
public Object getValue() {
switch (typetag) {
- case TypeTags.BOOLEAN:
+ case BOOLEAN:
int bi = (Integer) value;
return (bi != 0);
- case TypeTags.CHAR:
+ case CHAR:
int ci = (Integer) value;
char c = (char) ci;
if (c != ci)
@@ -1976,12 +1958,12 @@
/**
* Identifies a basic type.
- * @see TypeTags
+ * @see TypeTag
*/
public static class JCPrimitiveTypeTree extends JCExpression implements PrimitiveTypeTree {
/** the basic type id */
- public int typetag;
- protected JCPrimitiveTypeTree(int typetag) {
+ public TypeTag typetag;
+ protected JCPrimitiveTypeTree(TypeTag typetag) {
this.typetag = typetag;
}
@Override
@@ -1989,29 +1971,9 @@
public Kind getKind() { return Kind.PRIMITIVE_TYPE; }
public TypeKind getPrimitiveTypeKind() {
- switch (typetag) {
- case TypeTags.BOOLEAN:
- return TypeKind.BOOLEAN;
- case TypeTags.BYTE:
- return TypeKind.BYTE;
- case TypeTags.SHORT:
- return TypeKind.SHORT;
- case TypeTags.INT:
- return TypeKind.INT;
- case TypeTags.LONG:
- return TypeKind.LONG;
- case TypeTags.CHAR:
- return TypeKind.CHAR;
- case TypeTags.FLOAT:
- return TypeKind.FLOAT;
- case TypeTags.DOUBLE:
- return TypeKind.DOUBLE;
- case TypeTags.VOID:
- return TypeKind.VOID;
- default:
- throw new AssertionError("unknown primitive type " + this);
- }
+ return typetag.getPrimitiveTypeKind();
}
+
@Override
public <R,D> R accept(TreeVisitor<R,D> v, D d) {
return v.visitPrimitiveType(this, d);
@@ -2161,7 +2123,7 @@
}
@Override
public Tag getTag() {
- return WILDCARD;
+ return Tag.WILDCARD;
}
}
@@ -2362,8 +2324,8 @@
JCArrayAccess Indexed(JCExpression indexed, JCExpression index);
JCFieldAccess Select(JCExpression selected, Name selector);
JCIdent Ident(Name idname);
- JCLiteral Literal(int tag, Object value);
- JCPrimitiveTypeTree TypeIdent(int typetag);
+ JCLiteral Literal(TypeTag tag, Object value);
+ JCPrimitiveTypeTree TypeIdent(TypeTag typetag);
JCArrayTypeTree TypeArray(JCExpression elemtype);
JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments);
JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds);
--- a/langtools/src/share/classes/com/sun/tools/javac/tree/Pretty.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/tree/Pretty.java Thu Oct 25 11:09:36 2012 -0700
@@ -1133,28 +1133,28 @@
public void visitLiteral(JCLiteral tree) {
try {
switch (tree.typetag) {
- case TypeTags.INT:
+ case INT:
print(tree.value.toString());
break;
- case TypeTags.LONG:
+ case LONG:
print(tree.value + "L");
break;
- case TypeTags.FLOAT:
+ case FLOAT:
print(tree.value + "F");
break;
- case TypeTags.DOUBLE:
+ case DOUBLE:
print(tree.value.toString());
break;
- case TypeTags.CHAR:
+ case CHAR:
print("\'" +
Convert.quote(
String.valueOf((char)((Number)tree.value).intValue())) +
"\'");
break;
- case TypeTags.BOOLEAN:
+ case BOOLEAN:
print(((Number)tree.value).intValue() == 1 ? "true" : "false");
break;
- case TypeTags.BOT:
+ case BOT:
print("null");
break;
default:
@@ -1169,31 +1169,31 @@
public void visitTypeIdent(JCPrimitiveTypeTree tree) {
try {
switch(tree.typetag) {
- case TypeTags.BYTE:
+ case BYTE:
print("byte");
break;
- case TypeTags.CHAR:
+ case CHAR:
print("char");
break;
- case TypeTags.SHORT:
+ case SHORT:
print("short");
break;
- case TypeTags.INT:
+ case INT:
print("int");
break;
- case TypeTags.LONG:
+ case LONG:
print("long");
break;
- case TypeTags.FLOAT:
+ case FLOAT:
print("float");
break;
- case TypeTags.DOUBLE:
+ case DOUBLE:
print("double");
break;
- case TypeTags.BOOLEAN:
+ case BOOLEAN:
print("boolean");
break;
- case TypeTags.VOID:
+ case VOID:
print("void");
break;
default:
--- a/langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java Thu Oct 25 11:09:36 2012 -0700
@@ -34,6 +34,7 @@
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
import static com.sun.tools.javac.code.Flags.*;
+import static com.sun.tools.javac.code.TypeTag.BOT;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
import static com.sun.tools.javac.tree.JCTree.Tag.BLOCK;
import static com.sun.tools.javac.tree.JCTree.Tag.SYNCHRONIZED;
@@ -300,7 +301,7 @@
if (!tree.hasTag(LITERAL))
return false;
JCLiteral lit = (JCLiteral) tree;
- return (lit.typetag == TypeTags.BOT);
+ return (lit.typetag == BOT);
}
public static String getCommentText(Env<?> env, JCTree tree) {
--- a/langtools/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java Thu Oct 25 11:09:36 2012 -0700
@@ -35,7 +35,7 @@
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.*;
/** Factory class for trees.
*
@@ -426,13 +426,13 @@
return tree;
}
- public JCLiteral Literal(int tag, Object value) {
+ public JCLiteral Literal(TypeTag tag, Object value) {
JCLiteral tree = new JCLiteral(tag, value);
tree.pos = pos;
return tree;
}
- public JCPrimitiveTypeTree TypeIdent(int typetag) {
+ public JCPrimitiveTypeTree TypeIdent(TypeTag typetag) {
JCPrimitiveTypeTree tree = new JCPrimitiveTypeTree(typetag);
tree.pos = pos;
return tree;
@@ -629,10 +629,10 @@
public JCExpression Type(Type t) {
if (t == null) return null;
JCExpression tp;
- switch (t.tag) {
+ switch (t.getTag()) {
case BYTE: case CHAR: case SHORT: case INT: case LONG: case FLOAT:
case DOUBLE: case BOOLEAN: case VOID:
- tp = TypeIdent(t.tag);
+ tp = TypeIdent(t.getTag());
break;
case TYPEVAR:
tp = Ident(t.tsym);
@@ -644,7 +644,7 @@
}
case CLASS:
Type outer = t.getEnclosingType();
- JCExpression clazz = outer.tag == CLASS && t.tsym.owner.kind == TYP
+ JCExpression clazz = outer.hasTag(CLASS) && t.tsym.owner.kind == TYP
? Select(Type(outer), t.tsym)
: QualIdent(t.tsym);
tp = t.getTypeArguments().isEmpty()
@@ -849,7 +849,7 @@
* depending on whether the method invocation expression's type is void.
*/
public JCStatement Call(JCExpression apply) {
- return apply.type.tag == VOID ? Exec(apply) : Return(apply);
+ return apply.type.hasTag(VOID) ? Exec(apply) : Return(apply);
}
/** Construct an assignment from a variable symbol and a right hand side.
--- a/langtools/src/share/classes/com/sun/tools/javac/util/Constants.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/util/Constants.java Thu Oct 25 11:09:36 2012 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,8 +27,6 @@
import com.sun.tools.javac.code.Type;
-import static com.sun.tools.javac.code.TypeTags.*;
-
/**
* Utilities for operating on constant values.
*
@@ -48,7 +46,7 @@
public static Object decode(Object value, Type type) {
if (value instanceof Integer) {
int i = (Integer) value;
- switch (type.tag) {
+ switch (type.getTag()) {
case BOOLEAN: return i != 0;
case CHAR: return (char) i;
case BYTE: return (byte) i;
@@ -64,7 +62,7 @@
*/
public static String format(Object value, Type type) {
value = decode(value, type);
- switch (type.tag) {
+ switch (type.getTag()) {
case BYTE: return formatByte((Byte) value);
case LONG: return formatLong((Long) value);
case FLOAT: return formatFloat((Float) value);
--- a/langtools/src/share/classes/com/sun/tools/javac/util/RichDiagnosticFormatter.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javac/util/RichDiagnosticFormatter.java Thu Oct 25 11:09:36 2012 -0700
@@ -39,7 +39,7 @@
import com.sun.tools.javac.code.Type.*;
import com.sun.tools.javac.code.Types;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.*;
import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.util.LayoutCharacters.*;
import static com.sun.tools.javac.util.RichDiagnosticFormatter.RichConfiguration.*;
@@ -295,7 +295,7 @@
conflicts.contains(s))) {
List<Name> l = List.nil();
Symbol s2 = s;
- while (s2.type.getEnclosingType().tag == CLASS
+ while (s2.type.getEnclosingType().hasTag(CLASS)
&& s2.owner.kind == Kinds.TYP) {
l = l.prepend(s2.getSimpleName());
s2 = s2.owner;
@@ -414,7 +414,7 @@
? ownerName
: s.name.toString();
if (s.type != null) {
- if (s.type.tag == FORALL) {
+ if (s.type.hasTag(FORALL)) {
ms = "<" + visitTypes(s.type.getTypeArguments(), locale) + ">" + ms;
}
ms += "(" + printMethodArgs(
@@ -532,8 +532,8 @@
nameSimplifier.addUsage(t.tsym);
boolean boundErroneous = bounds.head == null ||
- bounds.head.tag == NONE ||
- bounds.head.tag == ERROR;
+ bounds.head.hasTag(NONE) ||
+ bounds.head.hasTag(ERROR);
if ((t.tsym.flags() & SYNTHETIC) == 0) {
//this is a true typevar
--- a/langtools/src/share/classes/com/sun/tools/javadoc/AnnotationValueImpl.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javadoc/AnnotationValueImpl.java Thu Oct 25 11:09:36 2012 -0700
@@ -29,8 +29,8 @@
import com.sun.tools.javac.code.Attribute;
import com.sun.tools.javac.code.Symbol.*;
-import com.sun.tools.javac.code.TypeTags;
+import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
/**
* Represents a value of an annotation type element.
@@ -76,7 +76,7 @@
public Object value;
public void visitConstant(Attribute.Constant c) {
- if (c.type.tag == TypeTags.BOOLEAN) {
+ if (c.type.hasTag(BOOLEAN)) {
// javac represents false and true as integers 0 and 1
value = Boolean.valueOf(
((Integer)c.value).intValue() != 0);
@@ -133,7 +133,7 @@
}
public void visitConstant(Attribute.Constant c) {
- if (c.type.tag == TypeTags.BOOLEAN) {
+ if (c.type.hasTag(BOOLEAN)) {
// javac represents false and true as integers 0 and 1
sb.append(((Integer)c.value).intValue() != 0);
} else {
--- a/langtools/src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java Thu Oct 25 11:09:36 2012 -0700
@@ -45,7 +45,6 @@
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.Type.ClassType;
-import com.sun.tools.javac.code.TypeTags;
import com.sun.tools.javac.comp.AttrContext;
import com.sun.tools.javac.comp.Env;
@@ -63,6 +62,7 @@
import com.sun.tools.javac.util.Position;
import static com.sun.tools.javac.code.Kinds.*;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
import static com.sun.tools.javac.tree.JCTree.Tag.*;
/**
@@ -164,7 +164,7 @@
if (isEnum() || isInterface() || isAnnotationType()) {
return false;
}
- for (Type t = type; t.tag == TypeTags.CLASS; t = env.types.supertype(t)) {
+ for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
if (t.tsym == env.syms.errorType.tsym ||
t.tsym == env.syms.exceptionType.tsym) {
return false;
@@ -201,7 +201,7 @@
if (isEnum() || isInterface() || isAnnotationType()) {
return false;
}
- for (Type t = type; t.tag == TypeTags.CLASS; t = env.types.supertype(t)) {
+ for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
if (t.tsym == env.syms.exceptionType.tsym) {
return true;
}
@@ -217,7 +217,7 @@
if (isEnum() || isInterface() || isAnnotationType()) {
return false;
}
- for (Type t = type; t.tag == TypeTags.CLASS; t = env.types.supertype(t)) {
+ for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
if (t.tsym == env.syms.errorType.tsym) {
return true;
}
@@ -232,7 +232,7 @@
if (isEnum() || isInterface() || isAnnotationType()) {
return false;
}
- for (Type t = type; t.tag == TypeTags.CLASS; t = env.types.supertype(t)) {
+ for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
if (t.tsym == env.syms.throwableType.tsym) {
return true;
}
--- a/langtools/src/share/classes/com/sun/tools/javadoc/FieldDocImpl.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javadoc/FieldDocImpl.java Thu Oct 25 11:09:36 2012 -0700
@@ -32,12 +32,13 @@
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Symbol.ClassSymbol;
import com.sun.tools.javac.code.Symbol.VarSymbol;
-import com.sun.tools.javac.code.TypeTags;
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
import com.sun.tools.javac.util.Position;
+import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
+
/**
* Represents a field in a java class.
*
@@ -103,7 +104,7 @@
*/
public Object constantValue() {
Object result = sym.getConstValue();
- if (result != null && sym.type.tag == TypeTags.BOOLEAN)
+ if (result != null && sym.type.hasTag(BOOLEAN))
// javac represents false and true as Integers 0 and 1
result = Boolean.valueOf(((Integer)result).intValue() != 0);
return result;
--- a/langtools/src/share/classes/com/sun/tools/javadoc/MethodDocImpl.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javadoc/MethodDocImpl.java Thu Oct 25 11:09:36 2012 -0700
@@ -31,10 +31,11 @@
import com.sun.tools.javac.code.*;
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.code.Type;
-import com.sun.tools.javac.code.TypeTags;
import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
import com.sun.tools.javac.util.Position;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
+
/**
* Represents a method of a java class.
*
@@ -129,7 +130,7 @@
ClassSymbol origin = (ClassSymbol)sym.owner;
for (Type t = env.types.supertype(origin.type);
- t.tag == TypeTags.CLASS;
+ t.hasTag(CLASS);
t = env.types.supertype(t)) {
ClassSymbol c = (ClassSymbol)t.tsym;
for (Scope.Entry e = c.members().lookup(sym.name); e.scope != null; e = e.next()) {
@@ -161,7 +162,7 @@
ClassSymbol origin = (ClassSymbol)sym.owner;
for (Type t = env.types.supertype(origin.type);
- t.tag == TypeTags.CLASS;
+ t.hasTag(CLASS);
t = env.types.supertype(t)) {
ClassSymbol c = (ClassSymbol)t.tsym;
for (Scope.Entry e = c.members().lookup(sym.name); e.scope != null; e = e.next()) {
--- a/langtools/src/share/classes/com/sun/tools/javadoc/ParameterizedTypeImpl.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javadoc/ParameterizedTypeImpl.java Thu Oct 25 11:09:36 2012 -0700
@@ -31,7 +31,7 @@
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.Type.ClassType;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
/**
@@ -95,7 +95,7 @@
* Return null is this is a top-level type.
*/
public com.sun.javadoc.Type containingType() {
- if (type.getEnclosingType().tag == CLASS) {
+ if (type.getEnclosingType().hasTag(CLASS)) {
// This is the type of an inner class.
return TypeMaker.getType(env, type.getEnclosingType());
}
@@ -134,7 +134,7 @@
return TypeMaker.getTypeName(cl, full);
}
StringBuilder s = new StringBuilder();
- if (cl.getEnclosingType().tag != CLASS) { // if not an inner class...
+ if (!(cl.getEnclosingType().hasTag(CLASS))) { // if not an inner class...
s.append(TypeMaker.getTypeName(cl, full));
} else {
ClassType encl = (ClassType)cl.getEnclosingType();
--- a/langtools/src/share/classes/com/sun/tools/javadoc/TypeMaker.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/src/share/classes/com/sun/tools/javadoc/TypeMaker.java Thu Oct 25 11:09:36 2012 -0700
@@ -33,7 +33,7 @@
import com.sun.tools.javac.code.Type.ClassType;
import com.sun.tools.javac.code.Type.TypeVar;
import com.sun.tools.javac.util.List;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.ARRAY;
/**
* <p><b>This is NOT part of any supported API.
@@ -57,7 +57,7 @@
if (env.legacyDoclet) {
t = env.types.erasure(t);
}
- switch (t.tag) {
+ switch (t.getTag()) {
case CLASS:
if (ClassDocImpl.isGeneric((ClassSymbol)t.tsym)) {
return env.getParameterizedType((ClassType)t);
@@ -107,10 +107,10 @@
}
public static String getTypeName(Type t, boolean full) {
- switch (t.tag) {
+ switch (t.getTag()) {
case ARRAY:
StringBuilder s = new StringBuilder();
- while (t.tag == ARRAY) {
+ while (t.hasTag(ARRAY)) {
s.append("[]");
t = ((ArrayType)t).elemtype;
}
@@ -129,10 +129,10 @@
* Class names are qualified if "full" is true.
*/
static String getTypeString(DocEnv env, Type t, boolean full) {
- switch (t.tag) {
+ switch (t.getTag()) {
case ARRAY:
StringBuilder s = new StringBuilder();
- while (t.tag == ARRAY) {
+ while (t.hasTag(ARRAY)) {
s.append("[]");
t = env.types.elemtype(t);
}
@@ -203,7 +203,7 @@
private com.sun.javadoc.Type skipArrays() {
if (skipArraysCache == null) {
Type t;
- for (t = arrayType; t.tag == ARRAY; t = env.types.elemtype(t)) { }
+ for (t = arrayType; t.hasTag(ARRAY); t = env.types.elemtype(t)) { }
skipArraysCache = TypeMaker.getType(env, t);
}
return skipArraysCache;
@@ -216,7 +216,7 @@
*/
public String dimension() {
StringBuilder dimension = new StringBuilder();
- for (Type t = arrayType; t.tag == ARRAY; t = env.types.elemtype(t)) {
+ for (Type t = arrayType; t.hasTag(ARRAY); t = env.types.elemtype(t)) {
dimension.append("[]");
}
return dimension.toString();
--- a/langtools/test/tools/javac/6889255/T6889255.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/test/tools/javac/6889255/T6889255.java Thu Oct 25 11:09:36 2012 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -36,7 +36,7 @@
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.Type.ClassType;
-import com.sun.tools.javac.code.TypeTags;
+import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.jvm.ClassReader;
import com.sun.tools.javac.util.Context;
@@ -436,7 +436,7 @@
// The rest of this method assumes the local conventions in the test program
Type t = v.type;
String s;
- if (t.tag == TypeTags.CLASS)
+ if (t.hasTag(TypeTag.CLASS))
s = ((ClassType) t).tsym.name.toString();
else
s = t.toString();
--- a/langtools/test/tools/javac/tree/MakeLiteralTest.java Tue Oct 23 13:58:56 2012 -0700
+++ b/langtools/test/tools/javac/tree/MakeLiteralTest.java Thu Oct 25 11:09:36 2012 -0700
@@ -1,7 +1,5 @@
-
-
/*
- * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -30,13 +28,14 @@
*/
import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.code.Symtab;
import com.sun.tools.javac.code.Types;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.tree.JCTree.JCLiteral;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.tree.TreeMaker;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.*;
public class MakeLiteralTest {
public static void main(String... args) throws Exception {
@@ -65,9 +64,9 @@
throw new Exception(errors + " errors found");
}
- void test(Object value, int tag, Type type, Object constValue) {
+ void test(Object value, TypeTag tag, Type type, Object constValue) {
JCLiteral l = maker.Literal(value);
- if (l.type.tag != tag)
+ if (!l.type.hasTag(tag))
error("unexpected tag: " + l.getTag() + ": expected: " + tag);
if (!types.isSameType(l.type, type))
error("unexpected type: " + l.type + ": expected: " + type);