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

-:4044eb07194d
+:dcd12fa5b58a
 unknownExprInfo = new ResultInfo(VAL, Type.noType);
 unknownAnyPolyInfo = new ResultInfo(VAL, Infer.anyPoly);
 unknownTypeInfo = new ResultInfo(TYP, Type.noType);
 unknownTypeExprInfo = new ResultInfo(Kinds.TYP | Kinds.VAL, Type.noType);
 recoveryInfo = new RecoveryInfo(deferredAttr.emptyDeferredAttrContext);
+noCheckTree = make.at(-1).Skip();
 }
 /** Switch: relax some constraints for retrofit mode.
 */
 boolean relax;
 *  @param resultInfo  The expected result of the tree
 */
 Type check(final JCTree tree, final Type found, final int ownkind, final ResultInfo resultInfo) {
 InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
 Type owntype;
-if (!found.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) {
+boolean shouldCheck = !found.hasTag(ERROR) &&
-if ((ownkind & ~resultInfo.pkind) != 0) {
+!resultInfo.pt.hasTag(METHOD) &&
-log.error(tree.pos(), "unexpected.type",
+!resultInfo.pt.hasTag(FORALL);
+if (shouldCheck && (ownkind & ~resultInfo.pkind) != 0) {
+log.error(tree.pos(), "unexpected.type",
 kindNames(resultInfo.pkind),
 kindName(ownkind));
 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;
+owntype = shouldCheck ? resultInfo.pt : found;
 inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() {
 @Override
 public void typesInferred(InferenceContext inferenceContext) {
 ResultInfo pendingResult =
 resultInfo.dup(inferenceContext.asInstType(resultInfo.pt));
 check(tree, inferenceContext.asInstType(found), ownkind, pendingResult);
 }
 });
-} else {
-owntype = resultInfo.check(tree, found);
-}
 } else {
-owntype = found;
+owntype = shouldCheck ?
-}
+resultInfo.check(tree, found) :
-tree.type = owntype;
+found;
+}
+if (tree != noCheckTree) {
+tree.type = owntype;
+}
 return owntype;
 }
 /** Is given blank final variable assignable, i.e. in a scope where it
 *  may be assigned to even though it is final?
 ResultInfo resultInfo;
 /** Visitor result: the computed type.
 */
 Type result;
+/** Synthetic tree to be used during 'fake' checks.
+*/
+JCTree noCheckTree;
 /** Visitor method: attribute a tree, catching any completion failure
 *  exceptions. Return the tree's type.
 *
 *  @param tree    The tree to be visited.
 enclosingContext.report(tree.clazz,
 diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", csym), details));
 }
 });
 Type constructorType = tree.constructorType = types.createErrorType(clazztype);
-constructorType = checkId(tree, site,
+constructorType = checkId(noCheckTree, site,
 constructor,
 diamondEnv,
 diamondResult);
 tree.clazz.type = types.createErrorType(clazztype);
 rsEnv.info.selectSuper = cdef != null;
 rsEnv.info.pendingResolutionPhase = null;
 tree.constructor = rs.resolveConstructor(
 tree.pos(), rsEnv, clazztype, argtypes, typeargtypes);
 if (cdef == null) { //do not check twice!
-tree.constructorType = checkId(tree,
+tree.constructorType = checkId(noCheckTree,
 clazztype,
 tree.constructor,
 rsEnv,
 new ResultInfo(pkind, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
 if (rsEnv.info.lastResolveVarargs())
 clazztype = cdef.sym.type;
 Symbol sym = tree.constructor = rs.resolveConstructor(
 tree.pos(), localEnv, clazztype, argtypes, typeargtypes);
 Assert.check(sym.kind < AMBIGUOUS);
 tree.constructor = sym;
-tree.constructorType = checkId(tree,
+tree.constructorType = checkId(noCheckTree,
 clazztype,
 tree.constructor,
 localEnv,
 new ResultInfo(pkind, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
 }
 if (tree.constructor != null && tree.constructor.kind == MTH)
 owntype = clazztype;
 }
 result = check(tree, owntype, VAL, resultInfo);
+InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
+if (tree.constructorType != null && inferenceContext.free(tree.constructorType)) {
+//we need to wait for inference to finish and then replace inference vars in the constructor type
+inferenceContext.addFreeTypeListener(List.of(tree.constructorType),
+new FreeTypeListener() {
+@Override
+public void typesInferred(InferenceContext instantiatedContext) {
+tree.constructorType = instantiatedContext.asInstType(tree.constructorType);
+}
+});
+}
 chk.validate(tree.typeargs, localEnv);
 }
 //where
 void findDiamond(Env<AttrContext> env, JCNewClass tree, Type clazztype) {
 JCTypeApply ta = (JCTypeApply)tree.clazz;
 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
 preFlow(that);
 flow.analyzeLambda(env, that, make, isSpeculativeRound);
+that.type = currentTarget; //avoids recovery at this stage
 checkLambdaCompatible(that, lambdaType, resultInfo.checkContext);
 if (!isSpeculativeRound) {
 //add thrown types as bounds to the thrown types free variables if needed:
 if (resultInfo.checkContext.inferenceContext().free(lambdaType.getThrownTypes())) {
 resultInfo.dup(newMethodTemplate(
 desc.getReturnType().hasTag(VOID) ? Type.noType : desc.getReturnType(),
 that.kind.isUnbound() ? argtypes.tail : argtypes, typeargtypes),
 new FunctionalReturnContext(resultInfo.checkContext));
-Type refType = checkId(that, lookupHelper.site, refSym, localEnv, checkInfo);
+Type refType = checkId(noCheckTree, lookupHelper.site, refSym, localEnv, checkInfo);
 if (that.kind.isUnbound() &&
 resultInfo.checkContext.inferenceContext().free(argtypes.head)) {
 //re-generate inference constraints for unbound receiver
 if (!types.isSubtype(resultInfo.checkContext.inferenceContext().asUndetVar(argtypes.head), exprType)) {
 //go ahead with standard method reference compatibility check - note that param check
 //is a no-op (as this has been taken care during method applicability)
 boolean isSpeculativeRound =
 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
+that.type = currentTarget; //avoids recovery at this stage
 checkReferenceCompatible(that, desc, refType, resultInfo.checkContext, isSpeculativeRound);
 if (!isSpeculativeRound) {
 checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), desc, currentTarget);
 }
 result = check(that, currentTarget, VAL, resultInfo);
 all_multicatchTypes.appendList(multicatchTypes);
 }
 all_multicatchTypes.append(ctype);
 }
 }
-Type t = check(tree, types.lub(multicatchTypes.toList()), TYP, resultInfo);
+Type t = check(noCheckTree, types.lub(multicatchTypes.toList()), TYP, resultInfo);
 if (t.hasTag(CLASS)) {
 List<Type> alternatives =
 ((all_multicatchTypes == null) ? multicatchTypes : all_multicatchTypes).toList();
 t = new UnionClassType((ClassType) t, alternatives);
 }

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