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

equal deleted inserted replaced

-:e21b18355690
+:ce94820fa9d1
 /*
-* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2017, 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
 import java.util.Map;
 import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.function.Function;
+import com.sun.source.tree.MemberReferenceTree;
+import com.sun.tools.javac.tree.JCTree.JCMemberReference.OverloadKind;
 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.
 return make.at(t.pos).NewClass(encl, typeargs, clazz, args, def);
 } else {
 return super.visitNewClass(node, p);
 }
 }
+@Override @DefinedBy(Api.COMPILER_TREE)
+public JCTree visitMemberReference(MemberReferenceTree node, Void p) {
+JCMemberReference t = (JCMemberReference) node;
+JCExpression expr = copy(t.expr, p);
+List<JCExpression> typeargs = copy(t.typeargs, p);
+/** once the value for overloadKind is determined for a copy, it can be safely forwarded to
+*  the copied tree, we want to profit from that
+*/
+JCMemberReference result = new JCMemberReference(t.mode, t.name, expr, typeargs) {
+@Override
+public void setOverloadKind(OverloadKind overloadKind) {
+super.setOverloadKind(overloadKind);
+if (t.getOverloadKind() == null) {
+t.setOverloadKind(overloadKind);
+}
+}
+};
+result.pos = t.pos;
+return result;
+}
 };
 deferredCopier = new TypeMapping<Void> () {
 @Override
 public Type visitType(Type t, Void v) {
 if (t.hasTag(DEFERRED)) {
 * restored after type-checking. All diagnostics (but critical ones) are
 * disabled during speculative type-checking.
 */
 JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
 return attribSpeculative(tree, env, resultInfo, treeCopier,
-(newTree)->new DeferredAttrDiagHandler(log, newTree));
+(newTree)->new DeferredAttrDiagHandler(log, newTree), null);
+}
+JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo, LocalCacheContext localCache) {
+return attribSpeculative(tree, env, resultInfo, treeCopier,
+(newTree)->new DeferredAttrDiagHandler(log, newTree), localCache);
 }
 <Z> JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo, TreeCopier<Z> deferredCopier,
-Function<JCTree, DeferredDiagnosticHandler> diagHandlerCreator) {
+Function<JCTree, DeferredDiagnosticHandler> diagHandlerCreator,
+LocalCacheContext localCache) {
 final JCTree newTree = deferredCopier.copy(tree);
 Env<AttrContext> speculativeEnv = env.dup(newTree, env.info.dup(env.info.scope.dupUnshared(env.info.scope.owner)));
 speculativeEnv.info.isSpeculative = true;
 Log.DeferredDiagnosticHandler deferredDiagnosticHandler = diagHandlerCreator.apply(newTree);
 try {
 attr.attribTree(newTree, speculativeEnv, resultInfo);
 return newTree;
 } finally {
 new UnenterScanner(env.toplevel.modle).scan(newTree);
 log.popDiagnosticHandler(deferredDiagnosticHandler);
+if (localCache != null) {
+localCache.leave();
+}
 }
 }
 //where
 class UnenterScanner extends TreeScanner {
 //do nothing
 }
 @Override
 public void visitReference(JCMemberReference tree) {
+Assert.checkNonNull(tree.getOverloadKind());
 Check.CheckContext checkContext = resultInfo.checkContext;
 Type pt = resultInfo.pt;
 if (!inferenceContext.inferencevars.contains(pt)) {
 try {
 types.findDescriptorType(pt);
 } catch (Types.FunctionDescriptorLookupError ex) {
 checkContext.report(null, ex.getDiagnostic());
 }
 Env<AttrContext> localEnv = env.dup(tree);
-JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
+JCExpression exprTree;
-attr.memberReferenceQualifierResult(tree));
+exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
+attr.memberReferenceQualifierResult(tree), argumentAttr.withLocalCacheContext());
 ListBuffer<Type> argtypes = new ListBuffer<>();
 for (Type t : types.findDescriptorType(pt).getParameterTypes()) {
 argtypes.append(Type.noType);
 }
 JCMemberReference mref2 = new TreeCopier<Void>(make).copy(tree);
 }
 Type descType = types.findDescriptorType(pt);
 List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());
 if (freeArgVars.nonEmpty() &&
-tree.overloadKind == JCMemberReference.OverloadKind.OVERLOADED) {
+tree.getOverloadKind() == JCMemberReference.OverloadKind.OVERLOADED) {
 stuckVars.addAll(freeArgVars);
 depVars.addAll(inferenceContext.freeVarsIn(descType.getReturnType()));
 }
 }
 }
 @Override
 public void visitReference(JCMemberReference tree) {
 super.visitReference(tree);
-if (tree.overloadKind == JCMemberReference.OverloadKind.OVERLOADED) {
+if (tree.getOverloadKind() == JCMemberReference.OverloadKind.OVERLOADED) {
 stuck = true;
 }
 }
 }
 }

changeset 44393	ce94820fa9d1
parent 44186	fe848a208b20
child 45504	ea7475564d07