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

-:1985e35e97b2
+:7873d37f5b37
 protected static final Context.Key<DeferredAttr> deferredAttrKey =
 new Context.Key<DeferredAttr>();
 final Attr attr;
 final Check chk;
+final JCDiagnostic.Factory diags;
 final Enter enter;
 final Infer infer;
 final Log log;
 final Symtab syms;
 final TreeMaker make;
 protected DeferredAttr(Context context) {
 context.put(deferredAttrKey, this);
 attr = Attr.instance(context);
 chk = Check.instance(context);
+diags = JCDiagnostic.Factory.instance(context);
 enter = Enter.instance(context);
 infer = Infer.instance(context);
 log = Log.instance(context);
 syms = Symtab.instance(context);
 make = TreeMaker.instance(context);
 types = Types.instance(context);
-}
+Names names = Names.instance(context);
+stuckTree = make.Ident(names.empty).setType(Type.noType);
+}
+/** shared tree for stuck expressions */
+final JCTree stuckTree;
 /**
 * This type represents a deferred type. A deferred type starts off with
 * no information on the underlying expression type. Such info needs to be
 * discovered through type-checking the deferred type against a target-type.
 Set<Type> stuckVars = new LinkedHashSet<Type>();
 boolean progress = false;
 //scan a defensive copy of the node list - this is because a deferred
 //attribution round can add new nodes to the list
 for (DeferredAttrNode deferredAttrNode : List.from(deferredAttrNodes)) {
-if (!deferredAttrNode.isStuck()) {
+if (!deferredAttrNode.process()) {
-deferredAttrNode.process();
+stuckVars.addAll(deferredAttrNode.stuckVars);
+} else {
 deferredAttrNodes.remove(deferredAttrNode);
 progress = true;
-} else {
-stuckVars.addAll(deferredAttrNode.stuckVars);
 }
 }
 if (!progress) {
 //remove all variables that have already been instantiated
 //from the list of stuck variables
 stuckVars = List.nil();
 resultInfo = resultInfo.dup(inferenceContext.asInstType(resultInfo.pt, types));
 }
 /**
-* is this node stuck?
-*/
-boolean isStuck() {
-return stuckVars.nonEmpty();
-}
-/**
 * Process a deferred attribution node.
 * Invariant: a stuck node cannot be processed.
 */
-void process() {
+@SuppressWarnings("fallthrough")
-if (isStuck()) {
+boolean process() {
-throw new IllegalStateException("Cannot process a stuck deferred node");
+switch (mode) {
-}
+case SPECULATIVE:
-dt.check(resultInfo);
+dt.check(resultInfo, List.<Type>nil(), new StructuralStuckChecker());
+return true;
+case CHECK:
+if (stuckVars.nonEmpty()) {
+return false;
+} else {
+dt.check(resultInfo, stuckVars, basicCompleter);
+return true;
+}
+default:
+throw new AssertionError("Bad mode");
+}
+}
+/**
+* Structural checker for stuck expressions
+*/
+class StructuralStuckChecker extends TreeScanner implements DeferredTypeCompleter {
+ResultInfo resultInfo;
+public Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
+this.resultInfo = resultInfo;
+dt.tree.accept(this);
+dt.speculativeCache.put(msym, stuckTree, phase);
+return Type.noType;
+}
+@Override
+public void visitLambda(JCLambda tree) {
+Check.CheckContext checkContext = resultInfo.checkContext;
+Type pt = resultInfo.pt;
+if (inferenceContext.inferencevars.contains(pt)) {
+//ok
+return;
+} else {
+//must be a functional descriptor
+try {
+Type desc = 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());
+}
+}
+}
+@Override
+public void visitNewClass(JCNewClass tree) {
+//do nothing
+}
+@Override
+public void visitApply(JCMethodInvocation tree) {
+//do nothing
+}
+@Override
+public void visitReference(JCMemberReference tree) {
+Check.CheckContext checkContext = resultInfo.checkContext;
+Type pt = resultInfo.pt;
+if (inferenceContext.inferencevars.contains(pt)) {
+//ok
+return;
+} else {
+try {
+//TODO: we should speculative determine if there's a match
+//based on arity - if yes, method is applicable.
+types.findDescriptorType(pt);
+} catch (Types.FunctionDescriptorLookupError ex) {
+checkContext.report(null, ex.getDiagnostic());
+}
+}
+}
 }
 }
 }
 /** an empty deferred attribution context - all methods throw exceptions */
 @Override
 public void visitLambda(JCLambda tree) {
 if (inferenceContext.inferenceVars().contains(pt)) {
 stuckVars.add(pt);
 }
-if (!types.isFunctionalInterface(pt.tsym)) {
+if (!types.isFunctionalInterface(pt)) {
 return;
 }
 Type descType = types.findDescriptorType(pt);
 List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());
-if (!TreeInfo.isExplicitLambda(tree) &&
+if (tree.paramKind == JCLambda.ParameterKind.IMPLICIT &&
 freeArgVars.nonEmpty()) {
 stuckVars.addAll(freeArgVars);
 }
 scanLambdaBody(tree, descType.getReturnType());
 }
 scan(tree.expr);
 if (inferenceContext.inferenceVars().contains(pt)) {
 stuckVars.add(pt);
 return;
 }
-if (!types.isFunctionalInterface(pt.tsym)) {
+if (!types.isFunctionalInterface(pt)) {
 return;
 }
 Type descType = types.findDescriptorType(pt);
 List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());

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

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

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