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

-:843d3b191773
+:01c9d4161882
 allowEnums = source.allowEnums();
 allowBoxing = source.allowBoxing();
 allowCovariantReturns = source.allowCovariantReturns();
 allowAnonOuterThis = source.allowAnonOuterThis();
 allowStringsInSwitch = source.allowStringsInSwitch();
-allowPoly = source.allowPoly() && options.isSet("allowPoly");
+allowPoly = source.allowPoly();
 allowLambda = source.allowLambda();
 allowDefaultMethods = source.allowDefaultMethods();
 sourceName = source.name;
 relax = (options.isSet("-retrofit") ||
 options.isSet("-relax"));
 /** Switch: support covariant result types?
 */
 boolean allowCovariantReturns;
+/** Switch: support lambda expressions ?
+*/
+boolean allowLambda;
 /** Switch: support default methods ?
 */
 boolean allowDefaultMethods;
-/** Switch: support lambda expressions ?
-*/
-boolean allowLambda;
 /** Switch: allow references to surrounding object from anonymous
 * objects during constructor call?
 */
 boolean allowAnonOuterThis;
 }
 protected ResultInfo dup(Type newPt) {
 return new ResultInfo(pkind, newPt, checkContext);
 }
+protected ResultInfo dup(CheckContext newContext) {
+return new ResultInfo(pkind, pt, newContext);
+}
 }
 class RecoveryInfo extends ResultInfo {
 public RecoveryInfo(final DeferredAttr.DeferredAttrContext deferredAttrContext) {
 public boolean compatible(Type found, Type req, Warner warn) {
 return true;
 }
 @Override
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
-//do nothing
+chk.basicHandler.report(pos, details);
 }
 });
 }
 @Override
 ResultInfo prevResult = this.resultInfo;
 try {
 this.env = env;
 this.resultInfo = resultInfo;
 tree.accept(this);
-if (tree == breakTree)
+if (tree == breakTree &&
+resultInfo.checkContext.deferredAttrContext().mode == AttrMode.CHECK) {
 throw new BreakAttr(env);
+}
 return result;
 } catch (CompletionFailure ex) {
 tree.type = syms.errType;
 return chk.completionError(tree.pos(), ex);
 } finally {
 // for attributing the method.
 Env<AttrContext> localEnv = memberEnter.methodEnv(tree, env);
 localEnv.info.lint = lint;
-if (isDefaultMethod && types.overridesObjectMethod(m)) {
+if (isDefaultMethod && types.overridesObjectMethod(m.enclClass(), m)) {
 log.error(tree, "default.overrides.object.member", m.name, Kinds.kindName(m.location()), m.location());
 }
 // Enter all type parameters into the local method scope.
 for (List<JCTypeParameter> l = tree.typarams; l.nonEmpty(); l = l.tail)
 pt().hasTag(NONE) && pt() != Type.recoveryType ||
 isBooleanOrNumeric(env, tree);
 if (!standaloneConditional && resultInfo.pt.hasTag(VOID)) {
 //cannot get here (i.e. it means we are returning from void method - which is already an error)
+resultInfo.checkContext.report(tree, diags.fragment("conditional.target.cant.be.void"));
 result = tree.type = types.createErrorType(resultInfo.pt);
 return;
 }
 ResultInfo condInfo = standaloneConditional ?
 unknownExprInfo :
-new ResultInfo(VAL, pt(), new Check.NestedCheckContext(resultInfo.checkContext) {
+resultInfo.dup(new Check.NestedCheckContext(resultInfo.checkContext) {
 //this will use enclosing check context to check compatibility of
 //subexpression against target type; if we are in a method check context,
 //depending on whether boxing is allowed, we could have incompatibilities
 @Override
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
 owntype = cfolder.coerce(condtype.isTrue() ? truetype : falsetype, owntype);
 }
 result = check(tree, owntype, VAL, resultInfo);
 }
 //where
-@SuppressWarnings("fallthrough")
 private boolean isBooleanOrNumeric(Env<AttrContext> env, JCExpression tree) {
 switch (tree.getTag()) {
 case LITERAL: return ((JCLiteral)tree).typetag.isSubRangeOf(DOUBLE) ||
-((JCLiteral)tree).typetag == BOOLEAN;
+((JCLiteral)tree).typetag == BOOLEAN ||
+((JCLiteral)tree).typetag == BOT;
 case LAMBDA: case REFERENCE: return false;
 case PARENS: return isBooleanOrNumeric(env, ((JCParens)tree).expr);
 case CONDEXPR:
 JCConditional condTree = (JCConditional)tree;
 return isBooleanOrNumeric(env, condTree.truepart) &&
 } else {
 // 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.hasTag(VOID)) {
-log.error(tree.expr.pos(),
+env.info.returnResult.checkContext.report(tree.expr.pos(),
-"cant.ret.val.from.meth.decl.void");
+diags.fragment("unexpected.ret.val"));
 }
 attribTree(tree.expr, env, env.info.returnResult);
 } else if (!env.info.returnResult.pt.hasTag(VOID)) {
-log.error(tree.pos(), "missing.ret.val");
+env.info.returnResult.checkContext.report(tree.pos(),
+diags.fragment("missing.ret.val"));
 }
 }
 result = null;
 }
 public void visitThrow(JCThrow tree) {
-attribExpr(tree.expr, env, syms.throwableType);
+Type owntype = attribExpr(tree.expr, env, allowPoly ? Type.noType : syms.throwableType);
+if (allowPoly) {
+chk.checkType(tree, owntype, syms.throwableType);
+}
 result = null;
 }
 public void visitAssert(JCAssert tree) {
 attribExpr(tree.cond, env, syms.booleanType);
 ta.arguments = List.nil();
 ResultInfo findDiamondResult = new ResultInfo(VAL,
 resultInfo.checkContext.inferenceContext().free(resultInfo.pt) ? Type.noType : pt());
 Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
 if (!inferred.isErroneous() &&
-types.isAssignable(inferred, pt().hasTag(NONE) ? syms.objectType : pt(), Warner.noWarnings)) {
+types.isAssignable(inferred, pt().hasTag(NONE) ? syms.objectType : pt(), types.noWarnings)) {
 String key = types.isSameType(clazztype, inferred) ?
 "diamond.redundant.args" :
 "diamond.redundant.args.1";
 log.warning(tree.clazz.pos(), key, clazztype, inferred);
 }
 result = that.type = types.createErrorType(pt());
 return;
 }
 //create an environment for attribution of the lambda expression
 final Env<AttrContext> localEnv = lambdaEnv(that, env);
-boolean needsRecovery = resultInfo.checkContext.deferredAttrContext() == deferredAttr.emptyDeferredAttrContext ||
+boolean needsRecovery =
 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK;
 try {
 List<Type> explicitParamTypes = null;
 if (TreeInfo.isExplicitLambda(that)) {
 //attribute lambda parameters
 attribStats(that.params, localEnv);
 explicitParamTypes = TreeInfo.types(that.params);
 }
-Type target = infer.instantiateFunctionalInterface(that, pt(), explicitParamTypes, resultInfo.checkContext);
+Type target;
-Type lambdaType = (target == Type.recoveryType) ?
+Type lambdaType;
-fallbackDescriptorType(that) :
+if (pt() != Type.recoveryType) {
-types.findDescriptorType(target);
+target = infer.instantiateFunctionalInterface(that, pt(), explicitParamTypes, resultInfo.checkContext);
+lambdaType = types.findDescriptorType(target);
+chk.checkFunctionalInterface(that, target);
+} else {
+target = Type.recoveryType;
+lambdaType = fallbackDescriptorType(that);
+}
 if (!TreeInfo.isExplicitLambda(that)) {
 //add param type info in the AST
 List<Type> actuals = lambdaType.getParameterTypes();
 List<JCVariableDecl> params = that.params;
 flow.analyzeLambda(env, that, make, isSpeculativeRound);
 checkLambdaCompatible(that, lambdaType, resultInfo.checkContext, isSpeculativeRound);
 if (!isSpeculativeRound) {
-checkAccessibleFunctionalDescriptor(that, localEnv, resultInfo.checkContext.inferenceContext(), lambdaType);
+checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), lambdaType, target);
 }
 result = check(that, target, VAL, resultInfo);
 } catch (Types.FunctionDescriptorLookupError ex) {
 JCDiagnostic cause = ex.getDiagnostic();
 resultInfo.checkContext.report(that, cause);
 Assert.error("Cannot get here!");
 }
 return null;
 }
-private void checkAccessibleFunctionalDescriptor(final DiagnosticPosition pos,
+private void checkAccessibleTypes(final DiagnosticPosition pos, final Env<AttrContext> env, final InferenceContext inferenceContext, final Type... ts) {
-final Env<AttrContext> env, final InferenceContext inferenceContext, final Type desc) {
+checkAccessibleTypes(pos, env, inferenceContext, List.from(ts));
-if (inferenceContext.free(desc)) {
+}
-inferenceContext.addFreeTypeListener(List.of(desc), new FreeTypeListener() {
+private void checkAccessibleTypes(final DiagnosticPosition pos, final Env<AttrContext> env, final InferenceContext inferenceContext, final List<Type> ts) {
+if (inferenceContext.free(ts)) {
+inferenceContext.addFreeTypeListener(ts, new FreeTypeListener() {
 @Override
 public void typesInferred(InferenceContext inferenceContext) {
-checkAccessibleFunctionalDescriptor(pos, env, inferenceContext, inferenceContext.asInstType(desc, types));
+checkAccessibleTypes(pos, env, inferenceContext, inferenceContext.asInstTypes(ts, types));
 }
 });
 } else {
-chk.checkAccessibleFunctionalDescriptor(pos, env, desc);
+for (Type t : ts) {
+rs.checkAccessibleType(env, t);
+}
 }
 }
 /**
 * Lambda/method reference have a special check context that ensures
 List<Type> typeargtypes = null;
 if (that.typeargs != null) {
 typeargtypes = attribTypes(that.typeargs, localEnv);
 }
-Type target = infer.instantiateFunctionalInterface(that, pt(), null, resultInfo.checkContext);
+Type target;
-Type desc = (target == Type.recoveryType) ?
+Type desc;
-fallbackDescriptorType(that) :
+if (pt() != Type.recoveryType) {
-types.findDescriptorType(target);
+target = infer.instantiateFunctionalInterface(that, pt(), null, resultInfo.checkContext);
+desc = types.findDescriptorType(target);
+chk.checkFunctionalInterface(that, target);
+} else {
+target = Type.recoveryType;
+desc = fallbackDescriptorType(that);
+}
 List<Type> argtypes = desc.getParameterTypes();
 boolean allowBoxing =
-resultInfo.checkContext.deferredAttrContext() == deferredAttr.emptyDeferredAttrContext ||
 resultInfo.checkContext.deferredAttrContext().phase.isBoxingRequired();
 Pair<Symbol, Resolve.ReferenceLookupHelper> refResult = rs.resolveMemberReference(that.pos(), localEnv, that,
 that.expr.type, that.name, argtypes, typeargtypes, allowBoxing);
 Symbol refSym = refResult.fst;
 JCDiagnostic.DiagnosticType.FRAGMENT : JCDiagnostic.DiagnosticType.ERROR;
 JCDiagnostic diag = diags.create(diagKind, log.currentSource(), that,
 "invalid.mref", Kinds.kindName(that.getMode()), detailsDiag);
-if (targetError) {
+if (targetError && target == Type.recoveryType) {
-resultInfo.checkContext.report(that, diag);
+//a target error doesn't make sense during recovery stage
+//as we don't know what actual parameter types are
+result = that.type = target;
+return;
 } else {
-log.report(diag);
+if (targetError) {
-}
+resultInfo.checkContext.report(that, diag);
-result = that.type = types.createErrorType(target);
+} else {
-return;
+log.report(diag);
+}
+result = that.type = types.createErrorType(target);
+return;
+}
 }
 if (desc.getReturnType() == Type.recoveryType) {
 // stop here
-result = that.type = types.createErrorType(target);
+result = that.type = target;
 return;
 }
 that.sym = refSym.baseSymbol();
 that.kind = lookupHelper.referenceKind(that.sym);
 //is a no-op (as this has been taken care during method applicability)
 boolean isSpeculativeRound =
 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
 checkReferenceCompatible(that, desc, refType, resultInfo.checkContext, isSpeculativeRound);
 if (!isSpeculativeRound) {
-checkAccessibleFunctionalDescriptor(that, localEnv, resultInfo.checkContext.inferenceContext(), desc);
+checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), desc, target);
 }
 result = check(that, target, VAL, resultInfo);
 } catch (Types.FunctionDescriptorLookupError ex) {
 JCDiagnostic cause = ex.getDiagnostic();
 resultInfo.checkContext.report(that, cause);
 incompatibleReturnType = null;
 }
 if (!returnType.hasTag(VOID) && !resType.hasTag(VOID)) {
 if (resType.isErroneous() ||
-new LambdaReturnContext(checkContext).compatible(resType, returnType, Warner.noWarnings)) {
+new LambdaReturnContext(checkContext).compatible(resType, returnType, types.noWarnings)) {
 incompatibleReturnType = null;
 }
 }
 if (incompatibleReturnType != null) {
 Type checkId(JCTree tree,
 Type site,
 Symbol sym,
 Env<AttrContext> env,
 ResultInfo resultInfo) {
-Type pt = resultInfo.pt.hasTag(FORALL) || resultInfo.pt.hasTag(METHOD) ?
+return (resultInfo.pt.hasTag(FORALL) || resultInfo.pt.hasTag(METHOD)) ?
-resultInfo.pt.map(deferredAttr.new DeferredTypeMap(AttrMode.SPECULATIVE, sym, env.info.pendingResolutionPhase)) :
+checkMethodId(tree, site, sym, env, resultInfo) :
-resultInfo.pt;
+checkIdInternal(tree, site, sym, resultInfo.pt, env, resultInfo);
+}
-DeferredAttr.DeferredTypeMap recoveryMap =
-deferredAttr.new RecoveryDeferredTypeMap(AttrMode.CHECK, sym, env.info.pendingResolutionPhase);
+Type checkMethodId(JCTree tree,
+Type site,
+Symbol sym,
+Env<AttrContext> env,
+ResultInfo resultInfo) {
+boolean isPolymorhicSignature =
+sym.kind == MTH && ((MethodSymbol)sym.baseSymbol()).isSignaturePolymorphic(types);
+return isPolymorhicSignature ?
+checkSigPolyMethodId(tree, site, sym, env, resultInfo) :
+checkMethodIdInternal(tree, site, sym, env, resultInfo);
+}
+Type checkSigPolyMethodId(JCTree tree,
+Type site,
+Symbol sym,
+Env<AttrContext> env,
+ResultInfo resultInfo) {
+//recover original symbol for signature polymorphic methods
+checkMethodIdInternal(tree, site, sym.baseSymbol(), env, resultInfo);
+env.info.pendingResolutionPhase = Resolve.MethodResolutionPhase.BASIC;
+return sym.type;
+}
+Type checkMethodIdInternal(JCTree tree,
+Type site,
+Symbol sym,
+Env<AttrContext> env,
+ResultInfo resultInfo) {
+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;
+}
+Type checkIdInternal(JCTree tree,
+Type site,
+Symbol sym,
+Type pt,
+Env<AttrContext> env,
+ResultInfo resultInfo) {
 if (pt.isErroneous()) {
-Type.map(resultInfo.pt.getParameterTypes(), recoveryMap);
 return types.createErrorType(site);
 }
 Type owntype; // The computed type of this identifier occurrence.
 switch (sym.kind) {
 case TYP:
 env, TreeInfo.args(env.tree), resultInfo.pt.getParameterTypes(),
 resultInfo.pt.getTypeArguments());
 break;
 }
 case PCK: case ERR:
-Type.map(resultInfo.pt.getParameterTypes(), recoveryMap);
 owntype = sym.type;
 break;
 default:
 throw new AssertionError("unexpected kind: " + sym.kind +
 " in tree " + tree);
 "unchecked.call.mbr.of.raw.type",
 sym, s);
 }
 }
-if (env.info.defaultSuperCallSite != null &&
+if (env.info.defaultSuperCallSite != null) {
-!types.interfaceCandidates(env.enclClass.type, (MethodSymbol)sym, true).contains(sym)) {
+for (Type sup : types.interfaces(env.enclClass.type).prepend(types.supertype((env.enclClass.type)))) {
-Symbol ovSym = null;
+if (!sup.tsym.isSubClass(sym.enclClass(), types) ||
-for (MethodSymbol msym : types.interfaceCandidates(env.enclClass.type, (MethodSymbol)sym, true)) {
+types.isSameType(sup, env.info.defaultSuperCallSite)) continue;
-if (msym.overrides(sym, msym.enclClass(), types, true)) {
+List<MethodSymbol> icand_sup =
-for (Type i : types.interfaces(env.enclClass.type)) {
+types.interfaceCandidates(sup, (MethodSymbol)sym);
-if (i.tsym.isSubClass(msym.owner, types)) {
+if (icand_sup.nonEmpty() &&
-ovSym = i.tsym;
+icand_sup.head != sym &&
-break;
+icand_sup.head.overrides(sym, icand_sup.head.enclClass(), types, true)) {
-}
+log.error(env.tree.pos(), "illegal.default.super.call", env.info.defaultSuperCallSite,
-}
+diags.fragment("overridden.default", sym, sup));
-}
+break;
 }
-log.error(env.tree.pos(), "illegal.default.super.call", env.info.defaultSuperCallSite,
+}
-diags.fragment("overridden.default", sym, ovSym));
+env.info.defaultSuperCallSite = null;
 }
 // Compute the identifier's instantiated type.
 // For methods, we need to compute the instance type by
 // Resolve.instantiate from the symbol's type as well as

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

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

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