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

equal deleted inserted replaced

-:fc4022e50129
+:1dfb66929538
 /*
-* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * questions.
 */
 package com.sun.tools.javac.comp;
-import com.sun.source.tree.MemberReferenceTree;
+import com.sun.source.tree.LambdaExpressionTree.BodyKind;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.comp.Attr.ResultInfo;
 import com.sun.tools.javac.comp.Infer.InferenceContext;
 import com.sun.tools.javac.comp.Resolve.MethodResolutionPhase;
-import com.sun.tools.javac.comp.Resolve.ReferenceLookupHelper;
 import com.sun.tools.javac.tree.JCTree.*;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.WeakHashMap;
+import static com.sun.tools.javac.code.Kinds.VAL;
 import static com.sun.tools.javac.code.TypeTag.*;
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
 /**
 * This is an helper class that is used to perform deferred type-analysis.
 final Resolve rs;
 final Log log;
 final Symtab syms;
 final TreeMaker make;
 final Types types;
+final Flow flow;
+final Names names;
 public static DeferredAttr instance(Context context) {
 DeferredAttr instance = context.get(deferredAttrKey);
 if (instance == null)
 instance = new DeferredAttr(context);
 rs = Resolve.instance(context);
 log = Log.instance(context);
 syms = Symtab.instance(context);
 make = TreeMaker.instance(context);
 types = Types.instance(context);
-Names names = Names.instance(context);
+flow = Flow.instance(context);
+names = Names.instance(context);
 stuckTree = make.Ident(names.empty).setType(Type.stuckType);
 emptyDeferredAttrContext =
 new DeferredAttrContext(AttrMode.CHECK, null, MethodResolutionPhase.BOX, infer.emptyContext, null, null) {
 @Override
 void addDeferredAttrNode(DeferredType dt, ResultInfo ri, DeferredStuckPolicy deferredStuckPolicy) {
 }
 @Override
 public TypeTag getTag() {
 return DEFERRED;
+}
+@Override
+public String toString() {
+return "DeferredType";
 }
 /**
 * A speculative cache is used to keep track of all overload resolution rounds
 * that triggered speculative attribution on a given deferred type. Each entry
 unenterScanner.scan(newTree);
 log.popDiagnosticHandler(deferredDiagnosticHandler);
 }
 }
 //where
-protected TreeScanner unenterScanner = new TreeScanner() {
+protected UnenterScanner unenterScanner = new UnenterScanner();
+class UnenterScanner extends TreeScanner {
 @Override
 public void visitClassDef(JCClassDecl tree) {
 ClassSymbol csym = tree.sym;
 //if something went wrong during method applicability check
 //it is possible that nested expressions inside argument expression
 enter.typeEnvs.remove(csym);
 chk.compiled.remove(csym.flatname);
 syms.classes.remove(csym.flatname);
 super.visitClassDef(tree);
 }
-};
+}
 /**
 * A deferred context is created on each method check. A deferred context is
 * used to keep track of information associated with the method check, such as
 * the symbol of the method being checked, the overload resolution phase,
 @Override
 public void visitLambda(JCLambda tree) {
 Check.CheckContext checkContext = resultInfo.checkContext;
 Type pt = resultInfo.pt;
-if (inferenceContext.inferencevars.contains(pt)) {
+if (!inferenceContext.inferencevars.contains(pt)) {
-//ok
-return;
-} else {
 //must be a functional descriptor
+Type descriptorType = null;
 try {
-Type desc = types.findDescriptorType(pt);
+descriptorType = types.findDescriptorType(pt);
-if (desc.getParameterTypes().length() != tree.params.length()) {
-checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
-}
 } catch (Types.FunctionDescriptorLookupError ex) {
 checkContext.report(null, ex.getDiagnostic());
 }
+if (descriptorType.getParameterTypes().length() != tree.params.length()) {
+checkContext.report(tree,
+diags.fragment("incompatible.arg.types.in.lambda"));
+}
+Type currentReturnType = descriptorType.getReturnType();
+boolean returnTypeIsVoid = currentReturnType.hasTag(VOID);
+if (tree.getBodyKind() == BodyKind.EXPRESSION) {
+boolean isExpressionCompatible = !returnTypeIsVoid ||
+TreeInfo.isExpressionStatement((JCExpression)tree.getBody());
+if (!isExpressionCompatible) {
+resultInfo.checkContext.report(tree.pos(),
+diags.fragment("incompatible.ret.type.in.lambda",
+diags.fragment("missing.ret.val", currentReturnType)));
+}
+} else {
+LambdaBodyStructChecker lambdaBodyChecker =
+new LambdaBodyStructChecker();
+tree.body.accept(lambdaBodyChecker);
+boolean isVoidCompatible = lambdaBodyChecker.isVoidCompatible;
+if (returnTypeIsVoid) {
+if (!isVoidCompatible) {
+resultInfo.checkContext.report(tree.pos(),
+diags.fragment("unexpected.ret.val"));
+}
+} else {
+boolean isValueCompatible = lambdaBodyChecker.isPotentiallyValueCompatible
+&& !canLambdaBodyCompleteNormally(tree);
+if (!isValueCompatible && !isVoidCompatible) {
+log.error(tree.body.pos(),
+"lambda.body.neither.value.nor.void.compatible");
+}
+if (!isValueCompatible) {
+resultInfo.checkContext.report(tree.pos(),
+diags.fragment("incompatible.ret.type.in.lambda",
+diags.fragment("missing.ret.val", currentReturnType)));
+}
+}
+}
+}
+}
+boolean canLambdaBodyCompleteNormally(JCLambda tree) {
+JCLambda newTree = new TreeCopier<>(make).copy(tree);
+/* attr.lambdaEnv will create a meaningful env for the
+* lambda expression. This is specially useful when the
+* lambda is used as the init of a field. But we need to
+* remove any added symbol.
+*/
+Env<AttrContext> localEnv = attr.lambdaEnv(newTree, env);
+try {
+List<JCVariableDecl> tmpParams = newTree.params;
+while (tmpParams.nonEmpty()) {
+tmpParams.head.vartype = make.at(tmpParams.head).Type(syms.errType);
+tmpParams = tmpParams.tail;
+}
+attr.attribStats(newTree.params, localEnv);
+/* set pt to Type.noType to avoid generating any bound
+* which may happen if lambda's return type is an
+* inference variable
+*/
+Attr.ResultInfo bodyResultInfo = attr.new ResultInfo(VAL, Type.noType);
+localEnv.info.returnResult = bodyResultInfo;
+// discard any log output
+Log.DiagnosticHandler diagHandler = new Log.DiscardDiagnosticHandler(log);
+try {
+JCBlock body = (JCBlock)newTree.body;
+/* we need to attribute the lambda body before
+* doing the aliveness analysis. This is because
+* constant folding occurs during attribution
+* and the reachability of some statements depends
+* on constant values, for example:
+*
+*     while (true) {...}
+*/
+attr.attribStats(body.stats, localEnv);
+attr.preFlow(newTree);
+/* make an aliveness / reachability analysis of the lambda
+* to determine if it can complete normally
+*/
+flow.analyzeLambda(localEnv, newTree, make, true);
+} finally {
+log.popDiagnosticHandler(diagHandler);
+}
+return newTree.canCompleteNormally;
+} finally {
+JCBlock body = (JCBlock)newTree.body;
+unenterScanner.scan(body.stats);
+localEnv.info.scope.leave();
 }
 }
 @Override
 public void visitNewClass(JCNewClass tree) {
 @Override
 public void visitReference(JCMemberReference tree) {
 Check.CheckContext checkContext = resultInfo.checkContext;
 Type pt = resultInfo.pt;
-if (inferenceContext.inferencevars.contains(pt)) {
+if (!inferenceContext.inferencevars.contains(pt)) {
-//ok
-return;
-} else {
 try {
 types.findDescriptorType(pt);
 } catch (Types.FunctionDescriptorLookupError ex) {
 checkContext.report(null, ex.getDiagnostic());
 }
 checkContext.report(tree, diags.fragment("incompatible.arg.types.in.mref"));
 }
 }
 }
 }
+/* This visitor looks for return statements, its analysis will determine if
+* a lambda body is void or value compatible. We must analyze return
+* statements contained in the lambda body only, thus any return statement
+* contained in an inner class or inner lambda body, should be ignored.
+*/
+class LambdaBodyStructChecker extends TreeScanner {
+boolean isVoidCompatible = true;
+boolean isPotentiallyValueCompatible = true;
+@Override
+public void visitClassDef(JCClassDecl tree) {
+// do nothing
+}
+@Override
+public void visitLambda(JCLambda tree) {
+// do nothing
+}
+@Override
+public void visitNewClass(JCNewClass tree) {
+// do nothing
+}
+@Override
+public void visitReturn(JCReturn tree) {
+if (tree.expr != null) {
+isVoidCompatible = false;
+} else {
+isPotentiallyValueCompatible = false;
+}
+}
+}
 }
 /** an empty deferred attribution context - all methods throw exceptions */
 final DeferredAttrContext emptyDeferredAttrContext;
 }
 /**
 * handler that is executed when a node has been discarded
 */
-abstract void skip(JCTree tree);
+void skip(JCTree tree) {}
 }
 /**
 * A tree scanner suitable for visiting the target-type dependent nodes of
 * a given argument expression.
 */
 static class PolyScanner extends FilterScanner {
 PolyScanner() {
 super(EnumSet.of(CONDEXPR, PARENS, LAMBDA, REFERENCE));
-}
-@Override
-void skip(JCTree tree) {
-//do nothing
 }
 }
 /**
 * A tree scanner suitable for visiting the target-type dependent nodes nested
 static class LambdaReturnScanner extends FilterScanner {
 LambdaReturnScanner() {
 super(EnumSet.of(BLOCK, CASE, CATCH, DOLOOP, FOREACHLOOP,
 FORLOOP, RETURN, SYNCHRONIZED, SWITCH, TRY, WHILELOOP));
-}
-@Override
-void skip(JCTree tree) {
-//do nothing
 }
 }
 /**
 * This visitor is used to check that structural expressions conform

changeset 24066	1dfb66929538
parent 22163	3651128c74eb
child 24226	08b586e22328