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

-:4a1c57a1c410
+:c002fdee76fd
 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.TypeTag.*;
-import static com.sun.tools.javac.code.TypeTags.WILDCARD;
+import static com.sun.tools.javac.code.TypeTag.WILDCARD;
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
 /** Type checking helper class for the attribution phase.
 *
 *  @param found      The type that was found.
 */
 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;
 }
 log.error(pos, "type.found.req", found, required);
 return types.createErrorType(found instanceof Type ? (Type)found : syms.errType);
 void checkTransparentClass(DiagnosticPosition pos, ClassSymbol c, Scope s) {
 if (s.next != null) {
 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);
 return;
 }
 public void typesInferred(InferenceContext inferenceContext) {
 checkType(pos, found, inferenceContext.asInstType(req, types), checkContext);
 }
 });
 }
-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);
 }
 checkContext.report(pos, diags.fragment("inconvertible.types", found, req));
 return types.createErrorType(found);
 //where
 /** Is type a type variable, or a (possibly multi-dimensional) array of
 *  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.
 *
 *  Used in TypeApply to verify that, e.g., X in {@code V<X>} is a valid
 *  @param bound         The bound.
 */
 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()) {
 return types.isCastable(bound, types.upperBound(a), Warner.noWarnings);
 } else if (a.isSuperBound()) {
 /** Check that type is different from 'void'.
 *  @param pos           Position to be used for error reporting.
 *  @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 {
 return t;
 }
 /** Check that type is a class or interface type.
 *  @param pos           Position to be used for error reporting.
 *  @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
 return t;
 }
 /** Check that type is a valid qualifier for a constructor reference expression
 */
 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);
 } else if ((t.tsym.flags() & ENUM) != 0) {
 log.error(pos, "enum.cant.be.instantiated");
 Type checkClassType(DiagnosticPosition pos, Type t, boolean noBounds) {
 t = checkClassType(pos, t);
 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);
 args = args.tail;
 }
 /** Check that type is a reifiable class, interface or array type.
 *  @param pos           Position to be used for error reporting.
 *  @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);
 } else if (!types.isReifiable(t)) {
 log.error(pos, "illegal.generic.type.for.instof");
 *  or a type variable.
 *  @param pos           Position to be used for error reporting.
 *  @param t             The type to be checked.
 */
 Type checkRefType(DiagnosticPosition pos, Type t) {
-switch (t.tag) {
+if (t.isReference())
-case CLASS:
-case ARRAY:
-case TYPEVAR:
-case WILDCARD:
-case ERROR:
 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
 *  or a type variable.
 *  @param trees         Original trees, used for error reporting.
 /** Check that type is a null or reference type.
 *  @param pos           Position to be used for error reporting.
 *  @param t             The type to be checked.
 */
 Type checkNullOrRefType(DiagnosticPosition pos, Type t) {
-switch (t.tag) {
+if (t.isNullOrReference())
-case CLASS:
-case ARRAY:
-case TYPEVAR:
-case WILDCARD:
-case BOT:
-case ERROR:
 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
 *  Return true if it doesn't.
 *  @param pos           Position to be used for error reporting.
 args = type.getTypeArguments();
 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)) {
 return args.head;
 }
 tree.elemtype.accept(this);
 }
 @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();
 Type incompatibleArg = firstIncompatibleTypeArg(tree.type);
 if (incompatibleArg != null) {
 validateTree(tree.inner, true, isOuter);
 }
 @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
 // not parameterized at all.
 if (tree.selected.type.isParameterized() && tree.type.tsym.type.getTypeArguments().nonEmpty())
 validateTree(l.head, checkRaw, isOuter);
 }
 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()) {
 log.warning(LintCategory.RAW,
 tree.pos(), "raw.class.use", tree.type, tree.type.tsym.type);
 /** Is exc an exception type that need not be declared?
 */
 boolean isUnchecked(Type exc) {
 return
-(exc.tag == TYPEVAR) ? isUnchecked(types.supertype(exc)) :
+(exc.hasTag(TYPEVAR)) ? isUnchecked(types.supertype(exc)) :
-(exc.tag == CLASS) ? isUnchecked((ClassSymbol)exc.tsym) :
+(exc.hasTag(CLASS)) ? isUnchecked((ClassSymbol)exc.tsym) :
-exc.tag == BOT;
+exc.hasTag(BOT);
 }
 /** Same, but handling completion failures.
 */
 boolean isUnchecked(DiagnosticPosition pos, Type exc) {
 // If the method, m, is not defined in an interface, then the only time we need to
 // address the issue is when the method is the supertype implemementation: any other
 // 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);
 if (mc != null && ((mc.flags() & INTERFACE) != 0)) {
 List<Type> intfs = types.interfaces(origin.type);
 *  @param pos          Position to be used for error reporting.
 *  @param site         The class type to be checked.
 */
 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();
 t1 = types.supertype(t1)) {
 for (Scope.Entry e1 = t1.tsym.members().elems;
 Type st1 = types.memberType(t1, s1);
 int s1ArgsLength = st1.getParameterTypes().length();
 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;
 e2 = e2.next()) {
 Symbol s2 = e2.sym;
 return null;
 }
 /** 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))
 closure(i, typeMap);
 }
 }
 /** 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);
 for (Type i : types.interfaces(t))
 closure(i, typesSkip, typeMap);
 List<Type> tvars2 = st2.getTypeArguments();
 Type rt1 = st1.getReturnType();
 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);
 if (!compat) {
 log.error(pos, "types.incompatible.diff.ret",
 Type rt1 = st1.getReturnType();
 Type rt2 = st2.getReturnType();
 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)
 return true;
 }
 if ((origin.flags() & ENUM) != 0 && names.finalize.equals(m.name))
 if (m.overrides(syms.enumFinalFinalize, origin, types, false)) {
 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);
 }
 for (Type t2 : types.interfaces(t)) {
 undef = absmeth;
 }
 }
 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);
 undef == null && l.nonEmpty();
 l = l.tail) {
 errorFound = true;
 noteCyclic(pos, (ClassSymbol)c);
 } 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);
 }
 else {
 ClassType ct = (ClassType)c.type;
 checkNonCyclic1(pos, t, List.<TypeVar>nil());
 }
 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))
 checkNonCyclic1(pos, b, seen);
 }
 if ((c.flags_field & LOCKED) != 0) {
 noteCyclic(pos, (ClassSymbol)c);
 } 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)
 complete &= checkNonCyclicInternal(pos, c.owner.type);
 }
 private void noteCyclic(DiagnosticPosition pos, ClassSymbol c) {
 log.error(pos, "cyclic.inheritance", c);
 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;
 }
 *  @param c            The class whose interfaces are checked.
 */
 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) {
 if (allowGenerics && !l.head.getTypeArguments().isEmpty() &&
 !checkCompatibleAbstracts(pos, l.head, l.head, c))
 * or in the interface annotation.Annotation."
 *
 * @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 &&
 (e.sym.flags() & (PUBLIC | PROTECTED)) != 0 &&
 types.overrideEquivalent(m.type, e.sym.type))
 { if (s.kind == PCK) return true; }
 else if (e.value.name == names.TYPE_USE)
 { 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
 return true; // recovery
 }
 tsym.flags_field |= ACYCLIC_ANN;
 }
 }
 void checkAnnotationResType(DiagnosticPosition pos, Type type) {
-switch (type.tag) {
+switch (type.getTag()) {
-case TypeTags.CLASS:
+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:
 break; // int etc
 }
 *  @param operand       The right hand operand for the expression
 */
 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
 || opc == ByteCodes.ldiv || opc == ByteCodes.lmod) {
 log.warning(LintCategory.DIVZERO, pos, "div.zero");

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

comparison: src/share/classes/com/sun/tools/javac/comp/Check.java

src/share/classes/com/sun/tools/javac/comp/Check.java