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

-:568e70bbd9aa
+:e28a06a3c5d9
 import com.sun.tools.javac.jvm.Target;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.code.Type.*;
+import com.sun.tools.javac.comp.Check.CheckContext;
 import com.sun.source.tree.IdentifierTree;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.TreeVisitor;
 import com.sun.source.util.SimpleTreeVisitor;
 relax = (options.isSet("-retrofit") ||
 options.isSet("-relax"));
 findDiamonds = options.get("findDiamond") != null &&
 source.allowDiamond();
 useBeforeDeclarationWarning = options.isSet("useBeforeDeclarationWarning");
+statInfo = new ResultInfo(NIL, Type.noType);
+varInfo = new ResultInfo(VAR, Type.noType);
+unknownExprInfo = new ResultInfo(VAL, Type.noType);
+unknownTypeInfo = new ResultInfo(TYP, Type.noType);
 }
 /** Switch: relax some constraints for retrofit mode.
 */
 boolean relax;
 *  @param resultInfo  The expected result of the tree
 */
 Type check(JCTree tree, Type owntype, int ownkind, ResultInfo resultInfo) {
 if (owntype.tag != ERROR && resultInfo.pt.tag != METHOD && resultInfo.pt.tag != FORALL) {
 if ((ownkind & ~resultInfo.pkind) == 0) {
-owntype = chk.checkType(tree.pos(), owntype, resultInfo.pt, errKey);
+owntype = resultInfo.check(tree, owntype);
 } else {
 log.error(tree.pos(), "unexpected.type",
 kindNames(resultInfo.pkind),
 kindName(ownkind));
 owntype = types.createErrorType(owntype);
 private BreakAttr(Env<AttrContext> env) {
 this.env = env;
 }
 }
-static class ResultInfo {
+class ResultInfo {
 int pkind;
 Type pt;
+CheckContext checkContext;
 ResultInfo(int pkind, Type pt) {
+this(pkind, pt, chk.basicHandler);
+}
+protected ResultInfo(int pkind, Type pt, CheckContext checkContext) {
 this.pkind = pkind;
 this.pt = pt;
-}
+this.checkContext = checkContext;
 }
-private final ResultInfo statInfo = new ResultInfo(NIL, Type.noType);
+protected Type check(DiagnosticPosition pos, Type found) {
-private final ResultInfo varInfo = new ResultInfo(VAR, Type.noType);
+return chk.checkType(pos, found, pt, checkContext);
-private final ResultInfo unknownExprInfo = new ResultInfo(VAL, Type.noType);
+}
-private final ResultInfo unknownTypeInfo = new ResultInfo(TYP, Type.noType);
+}
+private final ResultInfo statInfo;
+private final ResultInfo varInfo;
+private final ResultInfo unknownExprInfo;
+private final ResultInfo unknownTypeInfo;
 Type pt() {
 return resultInfo.pt;
 }
 Env<AttrContext> env;
 /** Visitor argument: the currently expected attribution result.
 */
 ResultInfo resultInfo;
-/** Visitor argument: the error key to be generated when a type error occurs
-*/
-String errKey;
 /** Visitor result: the computed type.
 */
 Type result;
 *  @param tree    The tree to be visited.
 *  @param env     The environment visitor argument.
 *  @param resultInfo   The result info visitor argument.
 */
 private Type attribTree(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
-return attribTree(tree, env, resultInfo, "incompatible.types");
-}
-private Type attribTree(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo, String errKey) {
 Env<AttrContext> prevEnv = this.env;
 ResultInfo prevResult = this.resultInfo;
-String prevErrKey = this.errKey;
 try {
 this.env = env;
 this.resultInfo = resultInfo;
-this.errKey = errKey;
 tree.accept(this);
 if (tree == breakTree)
 throw new BreakAttr(env);
 return result;
 } catch (CompletionFailure ex) {
 tree.type = syms.errType;
 return chk.completionError(tree.pos(), ex);
 } finally {
 this.env = prevEnv;
 this.resultInfo = prevResult;
-this.errKey = prevErrKey;
 }
 }
 /** Derived visitor method: attribute an expression tree.
 */
 public Type attribExpr(JCTree tree, Env<AttrContext> env, Type pt) {
-return attribExpr(tree, env, pt, "incompatible.types");
+return attribTree(tree, env, new ResultInfo(VAL, pt.tag != ERROR ? pt : Type.noType));
-}
-public Type attribExpr(JCTree tree, Env<AttrContext> env, Type pt, String key) {
-return attribTree(tree, env, new ResultInfo(VAL, pt.tag != ERROR ? pt : Type.noType), key);
 }
 /** Derived visitor method: attribute an expression tree with
 *  no constraints on the computed type.
 */
 Env<AttrContext> tryEnv = isTryWithResource ?
 env.dup(tree, localEnv.info.dup(localEnv.info.scope.dup())) :
 localEnv;
 // Attribute resource declarations
 for (JCTree resource : tree.resources) {
+CheckContext twrContext = new Check.NestedCheckContext(resultInfo.checkContext) {
+@Override
+public void report(DiagnosticPosition pos, Type found, Type req, JCDiagnostic details) {
+chk.basicHandler.report(pos, found, req, diags.fragment("try.not.applicable.to.type", found));
+}
+};
+ResultInfo twrResult = new ResultInfo(VAL, syms.autoCloseableType, twrContext);
 if (resource.hasTag(VARDEF)) {
 attribStat(resource, tryEnv);
-chk.checkType(resource, resource.type, syms.autoCloseableType, "try.not.applicable.to.type");
+twrResult.check(resource, resource.type);
 //check that resource type cannot throw InterruptedException
 checkAutoCloseable(resource.pos(), localEnv, resource.type);
 VarSymbol var = (VarSymbol)TreeInfo.symbolFor(resource);
 var.setData(ElementKind.RESOURCE_VARIABLE);
 } else {
-attribExpr(resource, tryEnv, syms.autoCloseableType, "try.not.applicable.to.type");
+attribTree(resource, tryEnv, twrResult);
 }
 }
 // Attribute body
 attribStat(tree.body, tryEnv);
 if (isTryWithResource)
 result = check(tree, owntype, VAL, resultInfo);
 chk.validate(tree.typeargs, localEnv);
 }
 Type attribDiamond(Env<AttrContext> env,
-JCNewClass tree,
+final JCNewClass tree,
 Type clazztype,
 List<Type> argtypes,
 List<Type> typeargtypes) {
 if (clazztype.isErroneous() ||
 clazztype.isInterface()) {
 localEnv.info.varArgs).getReturnType();
 } else {
 clazztype = syms.errType;
 }
-if (clazztype.tag == FORALL && !pt().isErroneous()) {
+if (clazztype.tag == FORALL && !resultInfo.pt.isErroneous()) {
-//if the resolved constructor's return type has some uninferred
-//type-variables, infer them using the expected type and declared
-//bounds (JLS 15.12.2.8).
 try {
-clazztype = infer.instantiateExpr((ForAll) clazztype,
+clazztype = resultInfo.checkContext.rawInstantiatePoly((ForAll)clazztype, pt(), Warner.noWarnings);
-pt().tag == NONE ? syms.objectType : pt(),
-Warner.noWarnings);
 } catch (Infer.InferenceException ex) {
 //an error occurred while inferring uninstantiated type-variables
-log.error(tree.clazz.pos(),
+resultInfo.checkContext.report(tree.clazz.pos(), clazztype, resultInfo.pt,
-"cant.apply.diamond.1",
+diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", clazztype.tsym), ex.diagnostic));
-diags.fragment("diamond", clazztype.tsym),
+}
-ex.diagnostic);
+}
-}
-}
+return chk.checkClassType(tree.clazz.pos(), clazztype, true);
-return chk.checkClassType(tree.clazz.pos(),
-clazztype,
-true);
 }
 /** Make an attributed null check tree.
 */
 public JCExpression makeNullCheck(JCExpression arg) {

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