jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java

equal deleted inserted replaced

-:41df50e7303d
+:228abfa87080
 import com.sun.tools.javac.util.List;
 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.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.Kinds.Kind.*;
 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
 findDiamonds = options.get("findDiamond") != null &&
 source.allowDiamond();
 useBeforeDeclarationWarning = options.isSet("useBeforeDeclarationWarning");
 identifyLambdaCandidate = options.getBoolean("identifyLambdaCandidate", false);
-statInfo = new ResultInfo(NIL, Type.noType);
+statInfo = new ResultInfo(KindSelector.NIL, Type.noType);
-varInfo = new ResultInfo(VAR, Type.noType);
+varInfo = new ResultInfo(KindSelector.VAR, Type.noType);
-unknownExprInfo = new ResultInfo(VAL, Type.noType);
+unknownExprInfo = new ResultInfo(KindSelector.VAL, Type.noType);
-unknownAnyPolyInfo = new ResultInfo(VAL, Infer.anyPoly);
+unknownAnyPolyInfo = new ResultInfo(KindSelector.VAL, Infer.anyPoly);
-unknownTypeInfo = new ResultInfo(TYP, Type.noType);
+unknownTypeInfo = new ResultInfo(KindSelector.TYP, Type.noType);
-unknownTypeExprInfo = new ResultInfo(Kinds.TYP | Kinds.VAL, Type.noType);
+unknownTypeExprInfo = new ResultInfo(KindSelector.VAL_TYP, Type.noType);
 recoveryInfo = new RecoveryInfo(deferredAttr.emptyDeferredAttrContext);
 }
 /** Switch: relax some constraints for retrofit mode.
 */
 *
 *  @param tree     The tree whose kind and type is checked
 *  @param ownkind  The computed kind of the tree
 *  @param resultInfo  The expected result of the tree
 */
-Type check(final JCTree tree, final Type found, final int ownkind, final ResultInfo resultInfo) {
+Type check(final JCTree tree,
+final Type found,
+final KindSelector ownkind,
+final ResultInfo resultInfo) {
 InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
 Type owntype;
 if (!found.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) {
-if ((ownkind & ~resultInfo.pkind) != 0) {
+if (!ownkind.subset(resultInfo.pkind)) {
 log.error(tree.pos(), "unexpected.type",
-kindNames(resultInfo.pkind),
+resultInfo.pkind.kindNames(),
-kindName(ownkind));
+ownkind.kindNames());
 owntype = types.createErrorType(found);
 } else if (allowPoly && inferenceContext.free(found)) {
 //delay the check if there are inference variables in the found type
 //this means we are dealing with a partially inferred poly expression
 owntype = resultInfo.pt;
 if (site.kind == ERR || site.kind == ABSENT_TYP)
 return site;
 Name name = (Name)node.getIdentifier();
 if (site.kind == PCK) {
 env.toplevel.packge = (PackageSymbol)site;
-return rs.findIdentInPackage(env, (TypeSymbol)site, name, TYP | PCK);
+return rs.findIdentInPackage(env, (TypeSymbol)site, name,
+KindSelector.TYP_PCK);
 } else {
 env.enclClass.sym = (ClassSymbol)site;
 return rs.findMemberType(env, site.asType(), name, (TypeSymbol)site);
 }
 }
 @Override @DefinedBy(Api.COMPILER_TREE)
 public Symbol visitIdentifier(IdentifierTree node, Env<AttrContext> env) {
-return rs.findIdent(env, (Name)node.getName(), TYP | PCK);
+return rs.findIdent(env, (Name)node.getName(), KindSelector.TYP_PCK);
 }
 }
 public Type coerce(Type etype, Type ttype) {
 return cfolder.coerce(etype, ttype);
 }
 public Type attribImportQualifier(JCImport tree, Env<AttrContext> env) {
 // Attribute qualifying package or class.
 JCFieldAccess s = (JCFieldAccess)tree.qualid;
-return attribTree(s.selected,
+return attribTree(s.selected, env,
-env,
+new ResultInfo(tree.staticImport ?
-new ResultInfo(tree.staticImport ? TYP : (TYP | PCK),
+KindSelector.TYP : KindSelector.TYP_PCK,
 Type.noType));
 }
 public Env<AttrContext> attribExprToTree(JCTree expr, Env<AttrContext> env, JCTree tree) {
 breakTree = tree;
 this.env = env;
 }
 }
 class ResultInfo {
-final int pkind;
+final KindSelector pkind;
 final Type pt;
 final CheckContext checkContext;
-ResultInfo(int pkind, Type pt) {
+ResultInfo(KindSelector pkind, Type pt) {
 this(pkind, pt, chk.basicHandler);
 }
-protected ResultInfo(int pkind, Type pt, CheckContext checkContext) {
+protected ResultInfo(KindSelector pkind,
+Type pt, CheckContext checkContext) {
 this.pkind = pkind;
 this.pt = pt;
 this.checkContext = checkContext;
 }
 }
 class RecoveryInfo extends ResultInfo {
 public RecoveryInfo(final DeferredAttr.DeferredAttrContext deferredAttrContext) {
-super(Kinds.VAL, Type.recoveryType, new Check.NestedCheckContext(chk.basicHandler) {
+super(KindSelector.VAL, Type.recoveryType,
+new Check.NestedCheckContext(chk.basicHandler) {
 @Override
 public DeferredAttr.DeferredAttrContext deferredAttrContext() {
 return deferredAttrContext;
 }
 @Override
 Type pt() {
 return resultInfo.pt;
 }
-int pkind() {
+KindSelector pkind() {
 return resultInfo.pkind;
 }
 /* ************************************************************************
 * Visitor methods
 }
 /** 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.hasTag(ERROR) ? pt : Type.noType));
+return attribTree(tree, env, new ResultInfo(KindSelector.VAL, !pt.hasTag(ERROR) ? pt : Type.noType));
 }
 /** Derived visitor method: attribute an expression tree with
 *  no constraints on the computed type.
 */
 }
 /** Derived visitor method: attribute a type tree.
 */
 Type attribType(JCTree tree, Env<AttrContext> env, Type pt) {
-Type result = attribTree(tree, env, new ResultInfo(TYP, pt));
+Type result = attribTree(tree, env, new ResultInfo(KindSelector.TYP, pt));
 return result;
 }
 /** Derived visitor method: attribute a statement or definition tree.
 */
 attribStat(l.head, env);
 }
 /** Attribute the arguments in a method call, returning the method kind.
 */
-int attribArgs(List<JCExpression> trees, Env<AttrContext> env, ListBuffer<Type> argtypes) {
+KindSelector attribArgs(List<JCExpression> trees, Env<AttrContext> env, ListBuffer<Type> argtypes) {
-int kind = VAL;
+boolean polykind = false;
 for (JCExpression arg : trees) {
 Type argtype;
 if (allowPoly && deferredAttr.isDeferred(env, arg)) {
 argtype = deferredAttr.new DeferredType(arg, env);
-kind |= POLY;
+polykind = true;
 } else {
 argtype = chk.checkNonVoid(arg, attribTree(arg, env, unknownAnyPolyInfo));
 }
 argtypes.append(argtype);
 }
-return kind;
+return polykind ? KindSelector.VAL_POLY : KindSelector.VAL;
 }
 /** Attribute a type argument list, returning a list of types.
 *  Caller is responsible for calling checkRefTypes.
 */
 }
 public void visitClassDef(JCClassDecl tree) {
 // Local and anonymous classes have not been entered yet, so we need to
 // do it now.
-if ((env.info.scope.owner.kind & (VAR | MTH)) != 0) {
+if (env.info.scope.owner.kind.matches(KindSelector.VAL_MTH)) {
 enter.classEnter(tree, env);
 } else {
 // If this class declaration is part of a class level annotation,
 // as in @MyAnno(new Object() {}) class MyClass {}, enter it in
 // order to simplify later steps and allow for sensible error
 @Override
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
 chk.basicHandler.report(pos, diags.fragment("try.not.applicable.to.type", details));
 }
 };
-ResultInfo twrResult = new ResultInfo(VAL, syms.autoCloseableType, twrContext);
+ResultInfo twrResult =
+new ResultInfo(KindSelector.VAL,
+syms.autoCloseableType,
+twrContext);
 if (resource.hasTag(VARDEF)) {
 attribStat(resource, tryEnv);
 twrResult.check(resource, resource.type);
 //check that resource type cannot throw InterruptedException
 Type ctype = attribStat(c.param, catchEnv);
 if (TreeInfo.isMultiCatch(c)) {
 //multi-catch parameter is implicitly marked as final
 c.param.sym.flags_field |= FINAL | UNION;
 }
-if (c.param.sym.kind == Kinds.VAR) {
+if (c.param.sym.kind == VAR) {
 c.param.sym.setData(ElementKind.EXCEPTION_PARAMETER);
 }
 chk.checkType(c.param.vartype.pos(),
 chk.checkClassType(c.param.vartype.pos(), ctype),
 syms.throwableType);
 falsetype.constValue() != null &&
 !owntype.hasTag(NONE)) {
 //constant folding
 owntype = cfolder.coerce(condtype.isTrue() ? truetype : falsetype, owntype);
 }
-result = check(tree, owntype, VAL, resultInfo);
+result = check(tree, owntype, KindSelector.VAL, resultInfo);
 }
 //where
 private boolean isBooleanOrNumeric(Env<AttrContext> env, JCExpression tree) {
 switch (tree.getTag()) {
 case LITERAL: return ((JCLiteral)tree).typetag.isSubRangeOf(DOUBLE) ||
 TreeInfo.setSymbol(tree.meth, sym);
 // ...and check that it is legal in the current context.
 // (this will also set the tree's type)
 Type mpt = newMethodTemplate(resultInfo.pt, argtypes, typeargtypes);
-checkId(tree.meth, site, sym, localEnv, new ResultInfo(MTH, mpt));
+checkId(tree.meth, site, sym, localEnv,
+new ResultInfo(KindSelector.MTH, mpt));
 }
 // Otherwise, `site' is an error type and we do nothing
 }
 result = tree.type = syms.voidType;
 } else {
 // Otherwise, we are seeing a regular method call.
 // Attribute the arguments, yielding list of argument types, ...
-int kind = attribArgs(tree.args, localEnv, argtypesBuf);
+KindSelector kind = attribArgs(tree.args, localEnv, argtypesBuf);
 argtypes = argtypesBuf.toList();
 typeargtypes = attribAnyTypes(tree.typeargs, localEnv);
 // ... and attribute the method using as a prototype a methodtype
 // whose formal argument types is exactly the list of actual
 chk.checkRefTypes(tree.typeargs, typeargtypes);
 // Check that value of resulting type is admissible in the
 // current context.  Also, capture the return type
-result = check(tree, capture(restype), VAL, resultInfo);
+result = check(tree, capture(restype), KindSelector.VAL, resultInfo);
 }
 chk.validate(tree.typeargs, localEnv);
 }
 //where
 Type adjustMethodReturnType(Type qualifierType, Name methodName, List<Type> argtypes, Type restype) {
 rs.resolveImplicitThis(tree.pos(), env, clazztype);
 }
 // Attribute constructor arguments.
 ListBuffer<Type> argtypesBuf = new ListBuffer<>();
-int pkind = attribArgs(tree.args, localEnv, argtypesBuf);
+final KindSelector pkind =
+attribArgs(tree.args, localEnv, argtypesBuf);
 List<Type> argtypes = argtypesBuf.toList();
 List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);
 // If we have made no mistakes in the class type...
 if (clazztype.hasTag(CLASS)) {
 // Reassign clazztype and recompute constructor.
 clazztype = cdef.sym.type;
 Symbol sym = tree.constructor = rs.resolveConstructor(
 tree.pos(), localEnv, clazztype, argtypes, typeargtypes);
-Assert.check(sym.kind < AMBIGUOUS);
+Assert.check(!sym.kind.isOverloadError());
 tree.constructor = sym;
 tree.constructorType = checkId(tree,
 clazztype,
 tree.constructor,
 localEnv,
 }
 if (tree.constructor != null && tree.constructor.kind == MTH)
 owntype = clazztype;
 }
-result = check(tree, owntype, VAL, resultInfo);
+result = check(tree, owntype, KindSelector.VAL, resultInfo);
 chk.validate(tree.typeargs, localEnv);
 }
 //where
 void findDiamond(Env<AttrContext> env, JCNewClass tree, Type clazztype) {
 JCTypeApply ta = (JCTypeApply)tree.clazz;
 List<JCExpression> prevTypeargs = ta.arguments;
 try {
 //create a 'fake' diamond AST node by removing type-argument trees
 ta.arguments = List.nil();
-ResultInfo findDiamondResult = new ResultInfo(VAL,
+ResultInfo findDiamondResult = new ResultInfo(KindSelector.VAL,
 resultInfo.checkContext.inferenceContext().free(resultInfo.pt) ? Type.noType : pt());
 Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
 Type polyPt = allowPoly ?
 syms.objectType :
 clazztype;
 attribExprs(tree.elems, localEnv, elemtype);
 owntype = new ArrayType(elemtype, syms.arrayClass);
 }
 if (!types.isReifiable(elemtype))
 log.error(tree.pos(), "generic.array.creation");
-result = check(tree, owntype, VAL, resultInfo);
+result = check(tree, owntype, KindSelector.VAL, resultInfo);
 }
 /*
 * A lambda expression can only be attributed when a target-type is available.
 * In addition, if the target-type is that of a functional interface whose
 new ExpressionLambdaReturnContext((JCExpression)that.getBody(), resultInfo.checkContext) :
 new FunctionalReturnContext(resultInfo.checkContext);
 ResultInfo bodyResultInfo = lambdaType.getReturnType() == Type.recoveryType ?
 recoveryInfo :
-new ResultInfo(VAL, lambdaType.getReturnType(), funcContext);
+new ResultInfo(KindSelector.VAL,
+lambdaType.getReturnType(), funcContext);
 localEnv.info.returnResult = bodyResultInfo;
 if (that.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
 attribTree(that.getBody(), localEnv, bodyResultInfo);
 } else {
 JCBlock body = (JCBlock)that.body;
 attribStats(body.stats, localEnv);
 }
-result = check(that, currentTarget, VAL, resultInfo);
+result = check(that, currentTarget, KindSelector.VAL, resultInfo);
 boolean isSpeculativeRound =
 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
 preFlow(that);
 chk.unhandled(inferredThrownTypes, thrownTypes);
 }
 checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), lambdaType, currentTarget);
 }
-result = check(that, currentTarget, VAL, resultInfo);
+result = check(that, currentTarget, KindSelector.VAL, resultInfo);
 } catch (Types.FunctionDescriptorLookupError ex) {
 JCDiagnostic cause = ex.getDiagnostic();
 resultInfo.checkContext.report(that, cause);
 result = that.type = types.createErrorType(pt());
 return;
 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
 checkReferenceCompatible(that, desc, refType, resultInfo.checkContext, isSpeculativeRound);
 if (!isSpeculativeRound) {
 checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), desc, currentTarget);
 }
-result = check(that, currentTarget, VAL, resultInfo);
+result = check(that, currentTarget, KindSelector.VAL, resultInfo);
 } catch (Types.FunctionDescriptorLookupError ex) {
 JCDiagnostic cause = ex.getDiagnostic();
 resultInfo.checkContext.report(that, cause);
 result = that.type = types.createErrorType(pt());
 return;
 }
 }
 //where
 ResultInfo memberReferenceQualifierResult(JCMemberReference tree) {
 //if this is a constructor reference, the expected kind must be a type
-return new ResultInfo(tree.getMode() == ReferenceMode.INVOKE ? VAL | TYP : TYP, Type.noType);
+return new ResultInfo(tree.getMode() == ReferenceMode.INVOKE ?
+KindSelector.VAL_TYP : KindSelector.TYP,
+Type.noType);
 }
 @SuppressWarnings("fallthrough")
 void checkReferenceCompatible(JCMemberReference tree, Type descriptor, Type refType, CheckContext checkContext, boolean speculativeAttr) {
 public void visitParens(JCParens tree) {
 Type owntype = attribTree(tree.expr, env, resultInfo);
 result = check(tree, owntype, pkind(), resultInfo);
 Symbol sym = TreeInfo.symbol(tree);
-if (sym != null && (sym.kind&(TYP|PCK)) != 0)
+if (sym != null && sym.kind.matches(KindSelector.TYP_PCK))
 log.error(tree.pos(), "illegal.start.of.type");
 }
 public void visitAssign(JCAssign tree) {
 Type owntype = attribTree(tree.lhs, env.dup(tree), varInfo);
 Type capturedType = capture(owntype);
 attribExpr(tree.rhs, env, owntype);
-result = check(tree, capturedType, VAL, resultInfo);
+result = check(tree, capturedType, KindSelector.VAL, resultInfo);
 }
 public void visitAssignop(JCAssignOp tree) {
 // Attribute arguments.
 Type owntype = attribTree(tree.lhs, env, varInfo);
 chk.checkDivZero(tree.rhs.pos(), operator, operand);
 chk.checkCastable(tree.rhs.pos(),
 operator.type.getReturnType(),
 owntype);
 }
-result = check(tree, owntype, VAL, resultInfo);
+result = check(tree, owntype, KindSelector.VAL, resultInfo);
 }
 public void visitUnary(JCUnary tree) {
 // Attribute arguments.
 Type argtype = (tree.getTag().isIncOrDecUnaryOp())
 if (ctype != null) {
 owntype = cfolder.coerce(ctype, owntype);
 }
 }
 }
-result = check(tree, owntype, VAL, resultInfo);
+result = check(tree, owntype, KindSelector.VAL, resultInfo);
 }
 public void visitBinary(JCBinary tree) {
 // Attribute arguments.
 Type left = chk.checkNonVoid(tree.lhs.pos(), attribExpr(tree.lhs, env));
 Type right = chk.checkNonVoid(tree.lhs.pos(), attribExpr(tree.rhs, env));
 // Find operator.
 Symbol operator = tree.operator =
 rs.resolveBinaryOperator(tree.pos(), tree.getTag(), env, left, right);
 Type owntype = types.createErrorType(tree.type);
 }
 }
 chk.checkDivZero(tree.rhs.pos(), operator, right);
 }
-result = check(tree, owntype, VAL, resultInfo);
+result = check(tree, owntype, KindSelector.VAL, resultInfo);
 }
 public void visitTypeCast(final JCTypeCast tree) {
 Type clazztype = attribType(tree.clazz, env);
 chk.validate(tree.clazz, env, false);
 final ResultInfo castInfo;
 JCExpression expr = TreeInfo.skipParens(tree.expr);
 boolean isPoly = allowPoly && (expr.hasTag(LAMBDA) || expr.hasTag(REFERENCE));
 if (isPoly) {
 //expression is a poly - we need to propagate target type info
-castInfo = new ResultInfo(VAL, clazztype, new Check.NestedCheckContext(resultInfo.checkContext) {
+castInfo = new ResultInfo(KindSelector.VAL, clazztype,
+new Check.NestedCheckContext(resultInfo.checkContext) {
 @Override
 public boolean compatible(Type found, Type req, Warner warn) {
 return types.isCastable(found, req, warn);
 }
 });
 }
 Type exprtype = attribTree(tree.expr, localEnv, castInfo);
 Type owntype = isPoly ? clazztype : chk.checkCastable(tree.expr.pos(), exprtype, clazztype);
 if (exprtype.constValue() != null)
 owntype = cfolder.coerce(exprtype, owntype);
-result = check(tree, capture(owntype), VAL, resultInfo);
+result = check(tree, capture(owntype), KindSelector.VAL, resultInfo);
 if (!isPoly)
 chk.checkRedundantCast(localEnv, tree);
 }
 public void visitTypeTest(JCInstanceOf tree) {
 Type exprtype = chk.checkNullOrRefType(
 tree.expr.pos(), attribExpr(tree.expr, env));
 Type clazztype = attribType(tree.clazz, env);
 if (!clazztype.hasTag(TYPEVAR)) {
 clazztype = chk.checkClassOrArrayType(tree.clazz.pos(), clazztype);
 }
 if (!clazztype.isErroneous() && !types.isReifiable(clazztype)) {
 log.error(tree.clazz.pos(), "illegal.generic.type.for.instof");
 clazztype = types.createErrorType(clazztype);
 }
 chk.validate(tree.clazz, env, false);
 chk.checkCastable(tree.expr.pos(), exprtype, clazztype);
-result = check(tree, syms.booleanType, VAL, resultInfo);
+result = check(tree, syms.booleanType, KindSelector.VAL, resultInfo);
 }
 public void visitIndexed(JCArrayAccess tree) {
 Type owntype = types.createErrorType(tree.type);
 Type atype = attribExpr(tree.indexed, env);
 attribExpr(tree.index, env, syms.intType);
 if (types.isArray(atype))
 owntype = types.elemtype(atype);
 else if (!atype.hasTag(ERROR))
 log.error(tree.pos(), "array.req.but.found", atype);
-if ((pkind() & VAR) == 0) owntype = capture(owntype);
+if (!pkind().contains(KindSelector.VAL))
-result = check(tree, owntype, VAR, resultInfo);
+owntype = capture(owntype);
+result = check(tree, owntype, KindSelector.VAR, resultInfo);
 }
 public void visitIdent(JCIdent tree) {
 Symbol sym;
 //     members since such classes don't carry a this$n link.
 //     (`noOuterThisPath').
 Env<AttrContext> symEnv = env;
 boolean noOuterThisPath = false;
 if (env.enclClass.sym.owner.kind != PCK && // we are in an inner class
-(sym.kind & (VAR | MTH | TYP)) != 0 &&
+sym.kind.matches(KindSelector.VAL_MTH) &&
 sym.owner.kind == TYP &&
 tree.name != names._this && tree.name != names._super) {
 // Find environment in which identifier is defined.
 while (symEnv.outer != null &&
 // illegal forward reference.
 checkInit(tree, env, v, false);
 // If we are expecting a variable (as opposed to a value), check
 // that the variable is assignable in the current environment.
-if (pkind() == VAR)
+if (pkind() == KindSelector.VAR)
 checkAssignable(tree.pos(), v, null, env);
 }
 // In a constructor body,
 // if symbol is a field or instance method, check that it is
 // not accessed before the supertype constructor is called.
 if ((symEnv.info.isSelfCall || noOuterThisPath) &&
-(sym.kind & (VAR | MTH)) != 0 &&
+sym.kind.matches(KindSelector.VAL_MTH) &&
 sym.owner.kind == TYP &&
 (sym.flags() & STATIC) == 0) {
-chk.earlyRefError(tree.pos(), sym.kind == VAR ? sym : thisSym(tree.pos(), env));
+chk.earlyRefError(tree.pos(), sym.kind == VAR ?
+sym : thisSym(tree.pos(), env));
 }
 Env<AttrContext> env1 = env;
-if (sym.kind != ERR && sym.kind != TYP && sym.owner != null && sym.owner != env1.enclClass.sym) {
+if (sym.kind != ERR && sym.kind != TYP &&
+sym.owner != null && sym.owner != env1.enclClass.sym) {
 // If the found symbol is inaccessible, then it is
 // accessed through an enclosing instance.  Locate this
 // enclosing instance:
 while (env1.outer != null && !rs.isAccessible(env, env1.enclClass.sym.type, sym))
 env1 = env1.outer;
 result = checkId(tree, env1.enclClass.sym.type, sym, env, resultInfo);
 }
 public void visitSelect(JCFieldAccess tree) {
 // Determine the expected kind of the qualifier expression.
-int skind = 0;
+KindSelector skind = KindSelector.NIL;
 if (tree.name == names._this || tree.name == names._super ||
 tree.name == names._class)
 {
-skind = TYP;
+skind = KindSelector.TYP;
 } else {
-if ((pkind() & PCK) != 0) skind = skind | PCK;
+if (pkind().contains(KindSelector.PCK))
-if ((pkind() & TYP) != 0) skind = skind | TYP | PCK;
+skind = KindSelector.of(skind, KindSelector.PCK);
-if ((pkind() & (VAL | MTH)) != 0) skind = skind | VAL | TYP;
+if (pkind().contains(KindSelector.TYP))
+skind = KindSelector.of(skind, KindSelector.TYP, KindSelector.PCK);
+if (pkind().contains(KindSelector.VAL_MTH))
+skind = KindSelector.of(skind, KindSelector.VAL, KindSelector.TYP);
 }
 // Attribute the qualifier expression, and determine its symbol (if any).
 Type site = attribTree(tree.selected, env, new ResultInfo(skind, Infer.anyPoly));
-if ((pkind() & (PCK | TYP)) == 0)
+if (!pkind().contains(KindSelector.TYP_PCK))
 site = capture(site); // Capture field access
 // don't allow T.class T[].class, etc
-if (skind == TYP) {
+if (skind == KindSelector.TYP) {
 Type elt = site;
 while (elt.hasTag(ARRAY))
 elt = ((ArrayType)elt).elemtype;
 if (elt.hasTag(TYPEVAR)) {
 log.error(tree.pos(), "type.var.cant.be.deref");
 sitesym.name == names._super;
 // Determine the symbol represented by the selection.
 env.info.pendingResolutionPhase = null;
 Symbol sym = selectSym(tree, sitesym, site, env, resultInfo);
-if (sym.exists() && !isType(sym) && (pkind() & (PCK | TYP)) != 0) {
+if (sym.exists() && !isType(sym) && pkind().contains(KindSelector.TYP_PCK)) {
 site = capture(site);
 sym = selectSym(tree, sitesym, site, env, resultInfo);
 }
 boolean varArgs = env.info.lastResolveVarargs();
 tree.sym = sym;
 // illegal forward reference.
 checkInit(tree, env, v, true);
 // If we are expecting a variable (as opposed to a value), check
 // that the variable is assignable in the current environment.
-if (pkind() == VAR)
+if (pkind() == KindSelector.VAR)
 checkAssignable(tree.pos(), v, tree.selected, env);
 }
 if (sitesym != null &&
 sitesym.kind == VAR &&
 env.info.lint.isEnabled(LintCategory.TRY)) {
 log.warning(LintCategory.TRY, tree, "try.explicit.close.call");
 }
 // Disallow selecting a type from an expression
-if (isType(sym) && (sitesym==null || (sitesym.kind&(TYP|PCK)) == 0)) {
+if (isType(sym) && (sitesym == null || !sitesym.kind.matches(KindSelector.TYP_PCK))) {
 tree.type = check(tree.selected, pt(),
-sitesym == null ? VAL : sitesym.kind, new ResultInfo(TYP|PCK, pt()));
+sitesym == null ?
+KindSelector.VAL : sitesym.kind.toSelector(),
+new ResultInfo(KindSelector.TYP_PCK, pt()));
 }
 if (isType(sitesym)) {
 if (sym.name == names._this) {
 // If `C' is the currently compiled class, check that
 }
 if (!allowStaticInterfaceMethods && sitesym.isInterface() &&
 sym.isStatic() && sym.kind == MTH) {
 log.error(tree.pos(), "static.intf.method.invoke.not.supported.in.source", sourceName);
 }
-} else if (sym.kind != ERR && (sym.flags() & STATIC) != 0 && sym.name != names._class) {
+} else if (sym.kind != ERR &&
+(sym.flags() & STATIC) != 0 &&
+sym.name != names._class) {
 // If the qualified item is not a type and the selected item is static, report
 // a warning. Make allowance for the class of an array type e.g. Object[].class)
-chk.warnStatic(tree, "static.not.qualified.by.type", Kinds.kindName(sym.kind), sym.owner);
+chk.warnStatic(tree, "static.not.qualified.by.type",
+sym.kind.kindName(), sym.owner);
 }
 // If we are selecting an instance member via a `super', ...
 if (env.info.selectSuper && (sym.flags() & STATIC) == 0) {
 return new VarSymbol(
 STATIC | PUBLIC | FINAL, names._class, t, site.tsym);
 } else {
 // We are seeing a plain identifier as selector.
 Symbol sym = rs.findIdentInType(env, site, name, resultInfo.pkind);
-if ((resultInfo.pkind & ERRONEOUS) == 0)
 sym = rs.accessBase(sym, pos, location, site, name, true);
 return sym;
 }
 case WILDCARD:
 throw new AssertionError(tree);
 Type checkMethodIdInternal(JCTree tree,
 Type site,
 Symbol sym,
 Env<AttrContext> env,
 ResultInfo resultInfo) {
-if ((resultInfo.pkind & POLY) != 0) {
+if (resultInfo.pkind.contains(KindSelector.POLY)) {
 Type pt = resultInfo.pt.map(deferredAttr.new RecoveryDeferredTypeMap(AttrMode.SPECULATIVE, sym, env.info.pendingResolutionPhase));
 Type owntype = checkIdInternal(tree, site, sym, pt, env, resultInfo);
 resultInfo.pt.map(deferredAttr.new RecoveryDeferredTypeMap(AttrMode.CHECK, sym, env.info.pendingResolutionPhase));
 return owntype;
 } else {
 case VAR:
 VarSymbol v = (VarSymbol)sym;
 // Test (4): if symbol is an instance field of a raw type,
 // which is being assigned to, issue an unchecked warning if
 // its type changes under erasure.
-if (resultInfo.pkind == VAR &&
+if (resultInfo.pkind == KindSelector.VAR &&
 v.owner.kind == TYP &&
 (v.flags() & STATIC) == 0 &&
 (site.hasTag(CLASS) || site.hasTag(TYPEVAR))) {
 Type s = types.asOuterSuper(site, v.owner);
 if (s != null &&
 // If the variable is a constant, record constant value in
 // computed type.
 if (v.getConstValue() != null && isStaticReference(tree))
 owntype = owntype.constType(v.getConstValue());
-if (resultInfo.pkind == VAL) {
+if (resultInfo.pkind == KindSelector.VAL) {
 owntype = capture(owntype); // capture "names as expressions"
 }
 break;
 case MTH: {
 owntype = checkMethod(site, sym,
 chk.checkProfile(tree.pos(), sym);
 }
 // Test (3): if symbol is a variable, check that its type and
 // kind are compatible with the prototype and protokind.
-return check(tree, owntype, sym.kind, resultInfo);
+return check(tree, owntype, sym.kind.toSelector(), resultInfo);
 }
 /** Check that variable is initialized and evaluate the variable's
 *  initializer, if not yet done. Also check that variable is not
 *  referenced before it is defined.
 return types.createErrorType(site);
 }
 }
 public void visitLiteral(JCLiteral tree) {
-result = check(
+result = check(tree, litType(tree.typetag).constType(tree.value),
-tree, litType(tree.typetag).constType(tree.value), VAL, resultInfo);
+KindSelector.VAL, resultInfo);
 }
 //where
 /** Return the type of a literal with given type 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.ordinal()], TYP, resultInfo);
+result = check(tree, syms.typeOfTag[tree.typetag.ordinal()], KindSelector.TYP, resultInfo);
 }
 public void visitTypeArray(JCArrayTypeTree tree) {
 Type etype = attribType(tree.elemtype, env);
 Type type = new ArrayType(etype, syms.arrayClass);
-result = check(tree, type, TYP, resultInfo);
+result = check(tree, type, KindSelector.TYP, resultInfo);
 }
 /** Visitor method for parameterized types.
 *  Bound checking is left until later, since types are attributed
 *  before supertype structure is completely known
 log.error(tree.pos(), "type.doesnt.take.params", clazztype.tsym);
 }
 owntype = types.createErrorType(tree.type);
 }
 }
-result = check(tree, owntype, TYP, resultInfo);
+result = check(tree, owntype, KindSelector.TYP, resultInfo);
 }
 public void visitTypeUnion(JCTypeUnion tree) {
 ListBuffer<Type> multicatchTypes = new ListBuffer<>();
 ListBuffer<Type> all_multicatchTypes = null; // lazy, only if needed
 all_multicatchTypes.appendList(multicatchTypes);
 }
 all_multicatchTypes.append(ctype);
 }
 }
-Type t = check(tree, types.lub(multicatchTypes.toList()), TYP, resultInfo);
+Type t = check(tree, types.lub(multicatchTypes.toList()),
+KindSelector.TYP, resultInfo);
 if (t.hasTag(CLASS)) {
 List<Type> alternatives =
 ((all_multicatchTypes == null) ? multicatchTypes : all_multicatchTypes).toList();
 t = new UnionClassType((ClassType) t, alternatives);
 }
 ? syms.objectType
 : attribType(tree.inner, env);
 result = check(tree, new WildcardType(chk.checkRefType(tree.pos(), type),
 tree.kind.kind,
 syms.boundClass),
-TYP, resultInfo);
+KindSelector.TYP, resultInfo);
 }
 public void visitAnnotation(JCAnnotation tree) {
 Assert.error("should be handled in Annotate");
 }
 }
 public void visitErroneous(JCErroneous tree) {
 if (tree.errs != null)
 for (JCTree err : tree.errs)
-attribTree(err, env, new ResultInfo(ERR, pt()));
+attribTree(err, env, new ResultInfo(KindSelector.ERR, pt()));
 result = tree.type = syms.errType;
 }
 /** Default visitor method for all other trees.
 */
 }
 public static final Filter<Symbol> anyNonAbstractOrDefaultMethod = new Filter<Symbol>() {
 @Override
 public boolean accepts(Symbol s) {
-return s.kind == Kinds.MTH &&
+return s.kind == MTH &&
 (s.flags() & (DEFAULT | ABSTRACT)) != ABSTRACT;
 }
 };
 /** get a diagnostic position for an attribute of Type t, or null if attribute missing */

changeset 27224	228abfa87080
parent 26991	88d998b3bb4b
child 27231	c1ca668b421e