infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-04-26 06:41:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

7200915: convert TypeTags from a series of small ints to an enum

Browse Source 
Reviewed-by: jjg, mcimadamore
This commit is contained in:
Vicente Romero 2012-10-25 11:09:36 -07:00 committed by Jonathan Gibbons
parent ce1db67272
commit de25999481
43 changed files with 758 additions and 640 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java
View File

@ -34,8 +34,6 @@ import javax.lang.model.type.DeclaredType;
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.

4
langtools/src/share/classes/com/sun/tools/javac/code/Kinds.java
View File

@ -32,7 +32,9 @@ import com.sun.source.tree.MemberReferenceTree;
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

5
langtools/src/share/classes/com/sun/tools/javac/code/Printer.java
View File

@ -32,9 +32,12 @@ import com.sun.tools.javac.code.Symbol.*;
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

38
langtools/src/share/classes/com/sun/tools/javac/code/Symbol.java
View File

@ -42,7 +42,9 @@ import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.Name;
import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.code.Kinds.*;
import static com.sun.tools.javac.code.TypeTags.*;
import static com.sun.tools.javac.code.TypeTag.CLASS;
import static com.sun.tools.javac.code.TypeTag.FORALL;
import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
/** Root class for Java symbols. It contains subclasses
* for specific sorts of symbols, such as variables, methods and operators,
@ -161,7 +163,7 @@ public abstract class Symbol implements Element {
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 @@ public abstract class Symbol implements Element {
/** 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 abstract class Symbol implements Element {
*/
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 abstract class Symbol implements Element {
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 @@ public abstract class Symbol implements Element {
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 @@ public abstract class Symbol implements Element {
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 @@ public abstract class Symbol implements Element {
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 @@ public abstract class Symbol implements Element {
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 @@ public abstract class Symbol implements Element {
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 abstract class Symbol implements Element {
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 abstract class Symbol implements Element {
}
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 @@ public abstract class Symbol implements Element {
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 abstract class Symbol implements Element {
*/
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 @@ public abstract class Symbol implements Element {
? 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) + ")";
}

31
langtools/src/share/classes/com/sun/tools/javac/code/Symtab.java
View File

@ -37,6 +37,7 @@ import com.sun.tools.javac.util.*;
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 @@ public class Symtab {
/** 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 @@ public class Symtab {
/** 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 class Symtab {
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 class Symtab {
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 class Symtab {
}
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 @@ public class Symtab {
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);

88
langtools/src/share/classes/com/sun/tools/javac/code/Type.java
View File

@ -38,7 +38,7 @@ import com.sun.tools.javac.util.*;
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 @@ import static com.sun.tools.javac.code.TypeTags.*;
* 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,14 +83,76 @@ public class Type implements PrimitiveType {
/** 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
@ -121,7 +183,7 @@ public class Type implements PrimitiveType {
/** 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 class Type implements PrimitiveType {
*/
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 @@ public class Type implements PrimitiveType {
return (tsym.flags() & FINAL) != 0;
}
public boolean isPrimitive() {
return tag < VOID;
}
/**
* Does this type contain occurrences of type t?
*/
@ -808,7 +866,7 @@ public class Type implements PrimitiveType {
}
public int hashCode() {
return (ARRAY << 5) + elemtype.hashCode();
return (ARRAY.ordinal() << 5) + elemtype.hashCode();
}
public boolean isVarargs() {
@ -915,7 +973,7 @@ public class Type implements PrimitiveType {
}
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 class Type implements PrimitiveType {
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 @@ public class Type implements PrimitiveType {
/** 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 @@ public class Type implements PrimitiveType {
static class BottomType extends Type implements NullType {
public BottomType() {
super(TypeTags.BOT, null);
super(BOT, null);
}
@Override

226
langtools/src/share/classes/com/sun/tools/javac/code/TypeTag.java Normal file
View File

@ -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);
}
}
}

140
langtools/src/share/classes/com/sun/tools/javac/code/TypeTags.java
View File

@ -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;
}

85
langtools/src/share/classes/com/sun/tools/javac/code/Types.java
View File

@ -40,7 +40,7 @@ import static com.sun.tools.javac.code.Flags.*;
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 @@ public class Types {
}
//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 @@ public class Types {
if (t == s)
return true;
if (s.tag >= firstPartialTag)
if (s.isPartial())
return isSuperType(s, t);
if (s.isCompound()) {
@ -686,25 +686,27 @@ public class Types {
{
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 @@ public class Types {
@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 @@ public class Types {
if (t == s)
return true;
if (s.tag >= firstPartialTag)
if (s.isPartial())
return visit(s, t);
switch (t.tag) {
@ -936,7 +938,7 @@ public class Types {
@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 @@ public class Types {
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 @@ public class Types {
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 class Types {
}
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 @@ public class Types {
@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 @@ public class Types {
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 @@ public class Types {
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 class Types {
*/
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 class Types {
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 @@ public class Types {
// 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 @@ public class Types {
// 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 @@ public class Types {
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 @@ public class Types {
* 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()]);
}
/**

6
langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java
View File

@ -34,6 +34,8 @@ import com.sun.tools.javac.code.Symbol.*;
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 @@ public class Annotate {
}
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 @@ public class Annotate {
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);

134
langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java
View File

@ -56,8 +56,8 @@ import static com.sun.tools.javac.code.Flags.ANNOTATION;
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
/** 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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
}
} 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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
@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 @@ public class Attr extends JCTree.Visitor {
default:
Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo).type;
speculativeType = types.unboxedTypeOrType(speculativeType);
return speculativeType.tag <= BOOLEAN;
return speculativeType.isPrimitive();
}
}
@ -1459,16 +1460,19 @@ public class Attr extends JCTree.Visitor {
// 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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
// 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 @@ public class Attr extends JCTree.Visitor {
}
}
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 @@ public class Attr extends JCTree.Visitor {
// 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 @@ public class Attr extends JCTree.Visitor {
}
}
} 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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
} 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 @@ public class Attr extends JCTree.Visitor {
*/
@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 @@ public class Attr extends JCTree.Visitor {
//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 @@ public class Attr extends JCTree.Visitor {
@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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
// 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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
// 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 @@ public class Attr extends JCTree.Visitor {
//
// 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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
// 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 @@ public class Attr extends JCTree.Visitor {
//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 @@ public class Attr extends JCTree.Visitor {
// 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 @@ public class Attr extends JCTree.Visitor {
}
// 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 @@ public class Attr extends JCTree.Visitor {
} 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 @@ public class Attr extends JCTree.Visitor {
}
}
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
* @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 @@ public class Attr extends JCTree.Visitor {
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 @@ public class Attr extends JCTree.Visitor {
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);

111
langtools/src/share/classes/com/sun/tools/javac/comp/Check.java
View File

@ -48,8 +48,8 @@ import static com.sun.tools.javac.code.Flags.*;
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 @@ public class Check {
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 @@ public class Check {
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 @@ public class Check {
}
});
}
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 @@ public class Check {
* 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 @@ public class Check {
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 @@ public class Check {
* @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 @@ public class Check {
* @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 @@ public class Check {
*/
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 @@ public class Check {
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 @@ public class Check {
* @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 @@ public class Check {
* @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 @@ public class Check {
* @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 @@ public class Check {
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 @@ public class Check {
@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 @@ public class Check {
@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 @@ public class Check {
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 @@ public class Check {
*/
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 @@ public class Check {
// 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 class Check {
*/
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 @@ public class Check {
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 @@ public class Check {
/** 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 @@ public class Check {
/** 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 @@ public class Check {
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 @@ public class Check {
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 @@ public class Check {
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 @@ public class Check {
}
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 @@ public class Check {
} 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 @@ public class Check {
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 @@ public class Check {
} 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 @@ public class Check {
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 @@ public class Check {
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 @@ public class Check {
* @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 @@ public class Check {
{ 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 @@ public class Check {
}
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 @@ public class Check {
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

17
langtools/src/share/classes/com/sun/tools/javac/comp/ConstFold.java
View File

@ -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.util.*;
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 @@ strictfp class ConstFold {
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 @@ strictfp class ConstFold {
/** 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 @@ strictfp class ConstFold {
// 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:

11
langtools/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java
View File

@ -44,7 +44,8 @@ import java.util.Queue;
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 @@ public class DeferredAttr extends JCTree.Visitor {
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 @@ public class DeferredAttr extends JCTree.Visitor {
@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 @@ public class DeferredAttr extends JCTree.Visitor {
@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 @@ public class DeferredAttr extends JCTree.Visitor {
*/
@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);

2
langtools/src/share/classes/com/sun/tools/javac/comp/Enter.java
View File

@ -49,7 +49,7 @@ import static com.sun.tools.javac.code.Kinds.*;
* 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.

9
langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java
View File

@ -40,7 +40,8 @@ import com.sun.tools.javac.tree.JCTree.*;
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 @@ public class Flow {
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 @@ public class Flow {
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

18
langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java
View File

@ -42,7 +42,7 @@ import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
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 @@ public class Infer {
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 @@ public class Infer {
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 @@ public class Infer {
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 @@ public class Infer {
//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 class Infer {
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 class Infer {
}
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);
}
};

20
langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java
View File

@ -45,7 +45,7 @@ import com.sun.tools.javac.tree.EndPosTable;
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 @@ public class Lower extends TreeTranslator {
* @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 @@ public class Lower extends TreeTranslator {
* 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 @@ public class Lower extends TreeTranslator {
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 @@ public class Lower extends TreeTranslator {
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 @@ public class Lower extends TreeTranslator {
}
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 @@ public class Lower extends TreeTranslator {
}
//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 @@ public class Lower extends TreeTranslator {
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 @@ public class Lower extends TreeTranslator {
/** 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 @@ public class Lower extends TreeTranslator {
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,

18
langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java
View File

@ -42,7 +42,9 @@ import com.sun.tools.javac.tree.JCTree.*;
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 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
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 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
}
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 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
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 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
}
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 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
@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 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
@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 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
@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);

54
langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java
View File

@ -59,7 +59,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.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 @@ public class Resolve {
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 @@ public class Resolve {
}
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 @@ public class Resolve {
// 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 @@ public class Resolve {
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 @@ public class Resolve {
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 @@ public class Resolve {
@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 @@ public class Resolve {
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 @@ public class Resolve {
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 @@ public class Resolve {
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 @@ public class Resolve {
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 @@ public class Resolve {
}
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 @@ public class Resolve {
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 @@ public class Resolve {
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 @@ public class Resolve {
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 @@ public class Resolve {
//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 class Resolve {
}
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 @@ public class Resolve {
//- 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 @@ public class Resolve {
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 @@ public class Resolve {
@Override
ReferenceKind referenceKind(Symbol sym) {
return site.getEnclosingType().tag == NONE ?
return site.getEnclosingType().hasTag(NONE) ?
ReferenceKind.TOPLEVEL : ReferenceKind.IMPLICIT_INNER;
}
}
@ -2847,7 +2847,7 @@ public class Resolve {
} 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 @@ public class Resolve {
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 @@ public class Resolve {
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,

18
langtools/src/share/classes/com/sun/tools/javac/comp/TransTypes.java
View File

@ -37,7 +37,9 @@ import com.sun.tools.javac.util.List;
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 @@ public class TransTypes extends TreeTranslator {
*/
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 @@ public class TransTypes extends TreeTranslator {
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 @@ public class TransTypes extends TreeTranslator {
*/
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 @@ public class TransTypes extends TreeTranslator {
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 class TransTypes extends TreeTranslator {
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 @@ public class TransTypes extends TreeTranslator {
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 @@ public class TransTypes extends TreeTranslator {
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);

6
langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java
View File

@ -55,7 +55,7 @@ import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
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 @@ public class ClassReader implements Completer {
* `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 @@ public class ClassReader implements Completer {
// 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

36
langtools/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java
View File

@ -45,7 +45,7 @@ import com.sun.tools.javac.util.*;
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 @@ public class ClassWriter extends ClassFile {
/** 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 @@ public class ClassWriter extends ClassFile {
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 @@ public class ClassWriter extends ClassFile {
* 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 @@ public class ClassWriter extends ClassFile {
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 @@ public class ClassWriter extends ClassFile {
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 @@ public class ClassWriter extends ClassFile {
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 @@ public class ClassWriter extends ClassFile {
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 @@ public class ClassWriter extends ClassFile {
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 @@ public class ClassWriter extends ClassFile {
}
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 @@ public class ClassWriter extends ClassFile {
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 @@ public class ClassWriter extends ClassFile {
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));

27
langtools/src/share/classes/com/sun/tools/javac/jvm/Code.java
View File

@ -30,7 +30,8 @@ import com.sun.tools.javac.code.Symbol.*;
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 @@ public class Code {
* 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 @@ public class Code {
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 @@ public class Code {
/** 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 @@ public class Code {
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 @@ public class Code {
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 @@ public class Code {
* 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 @@ public class Code {
}
}
static Type jsrReturnValue = new Type(TypeTags.INT, null);
static Type jsrReturnValue = new Type(INT, null);
/* **************************************************************************

22
langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java
View File

@ -42,7 +42,7 @@ import com.sun.tools.javac.tree.JCTree.*;
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 @@ public class Gen extends JCTree.Visitor {
*/
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 @@ public class Gen extends JCTree.Visitor {
*/
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 @@ public class Gen extends JCTree.Visitor {
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 class Gen extends JCTree.Visitor {
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 @@ public class Gen extends JCTree.Visitor {
// 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 @@ public class Gen extends JCTree.Visitor {
*/
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 @@ public class Gen extends JCTree.Visitor {
// 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 class Gen extends JCTree.Visitor {
}
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));

8
langtools/src/share/classes/com/sun/tools/javac/jvm/UninitializedType.java
View File

@ -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 @@ package com.sun.tools.javac.jvm;
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 @@ import com.sun.tools.javac.code.*;
* 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 @@ class UninitializedType extends Type.DelegatedType {
}
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;
}

3
langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java
View File

@ -63,6 +63,7 @@ import com.sun.tools.javac.tree.JCTree.*;
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 @@ public class JavaCompiler implements ClassReader.SourceCompleter {
@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) {

7
langtools/src/share/classes/com/sun/tools/javac/model/JavacElements.java
View File

@ -38,7 +38,7 @@ import static javax.lang.model.util.ElementFilter.methodsIn;
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.TreeInfo;
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 @@ public class JavacElements implements Elements {
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 @@ public class JavacElements implements Elements {
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;
}

50
langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java
View File

@ -560,7 +560,7 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
// 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 @@ public class JavacParser implements Parser {
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 @@ public class JavacParser implements Parser {
}
/** 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;
}
}

68
langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java
View File

@ -81,7 +81,7 @@ import static com.sun.tools.javac.tree.JCTree.Tag.*;
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 @@ public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
* 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 abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
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 @@ public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
/**
* 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 abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
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 @@ public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
}
@Override
public Tag getTag() {
return WILDCARD;
return Tag.WILDCARD;
}
}
@ -2362,8 +2324,8 @@ public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
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);

32
langtools/src/share/classes/com/sun/tools/javac/tree/Pretty.java
View File

@ -1133,28 +1133,28 @@ public class Pretty extends JCTree.Visitor {
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 class Pretty extends JCTree.Visitor {
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:

3
langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java
View File

@ -34,6 +34,7 @@ import com.sun.tools.javac.tree.JCTree.*;
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 @@ public class TreeInfo {
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) {

14
langtools/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java
View File

@ -35,7 +35,7 @@ import com.sun.tools.javac.tree.JCTree.*;
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 @@ public class TreeMaker implements JCTree.Factory {
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 class TreeMaker implements JCTree.Factory {
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 @@ public class TreeMaker implements JCTree.Factory {
}
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 @@ public class TreeMaker implements JCTree.Factory {
* 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.

8
langtools/src/share/classes/com/sun/tools/javac/util/Constants.java
View File

@ -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 @@ package com.sun.tools.javac.util;
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 class Constants {
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 class Constants {
*/
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);

10
langtools/src/share/classes/com/sun/tools/javac/util/RichDiagnosticFormatter.java
View File

@ -39,7 +39,7 @@ import com.sun.tools.javac.code.Type;
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 @@ public class RichDiagnosticFormatter extends
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 @@ public class RichDiagnosticFormatter extends
? 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 @@ public class RichDiagnosticFormatter extends
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

6
langtools/src/share/classes/com/sun/tools/javadoc/AnnotationValueImpl.java
View File

@ -29,8 +29,8 @@ import com.sun.javadoc.*;
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 class AnnotationValueImpl implements AnnotationValue {
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 class AnnotationValueImpl implements AnnotationValue {
}
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 {

10
langtools/src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java
View File

@ -45,7 +45,6 @@ import com.sun.tools.javac.code.Symbol;
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.Names;
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 @@ public class ClassDocImpl extends ProgramElementDocImpl implements ClassDoc {
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 @@ public class ClassDocImpl extends ProgramElementDocImpl implements ClassDoc {
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 @@ public class ClassDocImpl extends ProgramElementDocImpl implements ClassDoc {
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 @@ public class ClassDocImpl extends ProgramElementDocImpl implements ClassDoc {
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;
}

5
langtools/src/share/classes/com/sun/tools/javadoc/FieldDocImpl.java
View File

@ -32,12 +32,13 @@ import com.sun.javadoc.*;
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 class FieldDocImpl extends MemberDocImpl implements FieldDoc {
*/
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;

7
langtools/src/share/classes/com/sun/tools/javadoc/MethodDocImpl.java
View File

@ -31,10 +31,11 @@ import com.sun.javadoc.*;
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 @@ public class MethodDocImpl
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 @@ public class MethodDocImpl
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()) {

6
langtools/src/share/classes/com/sun/tools/javadoc/ParameterizedTypeImpl.java
View File

@ -31,7 +31,7 @@ import com.sun.tools.javac.code.Symbol.ClassSymbol;
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 @@ public class ParameterizedTypeImpl
* 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 @@ public class ParameterizedTypeImpl
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();

16
langtools/src/share/classes/com/sun/tools/javadoc/TypeMaker.java
View File

@ -33,7 +33,7 @@ import com.sun.tools.javac.code.Type.ArrayType;
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 @@ public class TypeMaker {
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 class TypeMaker {
}
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 @@ public class TypeMaker {
* 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 @@ public class TypeMaker {
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 class TypeMaker {
*/
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();

6
langtools/test/tools/javac/6889255/T6889255.java
View File

@ -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.Scope;
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 @@ public class T6889255 {
// 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();

11
langtools/test/tools/javac/tree/MakeLiteralTest.java
View File

@ -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 @@ public class MakeLiteralTest {
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);