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

-:260013a710ef
+:8e27e84de2e9
 import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol;
 import com.sun.tools.javac.code.Symbol.MethodSymbol;
 import com.sun.tools.javac.code.Symbol.VarSymbol;
 import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.code.Type;
-import com.sun.tools.javac.code.Type.ClassType;
 import com.sun.tools.javac.code.Type.MethodType;
 import com.sun.tools.javac.code.Types;
-import com.sun.tools.javac.comp.LambdaToMethod.LambdaAnalyzer.*;
+import com.sun.tools.javac.comp.LambdaToMethod.LambdaAnalyzerPreprocessor.*;
 import com.sun.tools.javac.comp.Lower.BasicFreeVarCollector;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 private Types types;
 private TransTypes transTypes;
 private Env<AttrContext> attrEnv;
 /** the analyzer scanner */
-private LambdaAnalyzer analyzer;
+private LambdaAnalyzerPreprocessor analyzer;
 /** map from lambda trees to translation contexts */
 private Map<JCTree, TranslationContext<?>> contextMap;
 /** current translation context (visitor argument) */
 syms = Symtab.instance(context);
 rs = Resolve.instance(context);
 make = TreeMaker.instance(context);
 types = Types.instance(context);
 transTypes = TransTypes.instance(context);
-analyzer = new LambdaAnalyzer();
+analyzer = new LambdaAnalyzerPreprocessor();
 }
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="translate methods">
 @Override
 */
 @Override
 public void visitClassDef(JCClassDecl tree) {
 if (tree.sym.owner.kind == PCK) {
 //analyze class
-analyzer.analyzeClass(tree);
+tree = analyzer.analyzeAndPreprocessClass(tree);
 }
 KlassInfo prevKlassInfo = kInfo;
 try {
 kInfo = new KlassInfo(tree.sym);
 super.visitClassDef(tree);
 }
 /** Make an attributed class instance creation expression.
 *  @param ctype    The class type.
 *  @param args     The constructor arguments.
+*  @param cons     The constructor symbol
+*/
+JCNewClass makeNewClass(Type ctype, List<JCExpression> args, Symbol cons) {
+JCNewClass tree = make.NewClass(null,
+null, make.QualIdent(ctype.tsym), args, null);
+tree.constructor = cons;
+tree.type = ctype;
+return tree;
+}
+/** Make an attributed class instance creation expression.
+*  @param ctype    The class type.
+*  @param args     The constructor arguments.
 */
 JCNewClass makeNewClass(Type ctype, List<JCExpression> args) {
-JCNewClass tree = make.NewClass(null,
+return makeNewClass(ctype, args,
-null, make.QualIdent(ctype.tsym), args, null);
+rs.resolveConstructor(null, attrEnv, ctype, TreeInfo.types(args), List.<Type>nil()));
-tree.constructor = rs.resolveConstructor(
+}
-null, attrEnv, ctype, TreeInfo.types(args), List.<Type>nil());
-tree.type = ctype;
-return tree;
-}
 private void addDeserializationCase(int implMethodKind, Symbol refSym, Type targetType, MethodSymbol samSym,
 DiagnosticPosition pos, List<Object> staticArgs, MethodType indyType) {
 String functionalInterfaceClass = classSig(targetType);
 String functionalInterfaceMethodName = samSym.getSimpleName().toString();
 // <editor-fold defaultstate="collapsed" desc="Lambda/reference analyzer">
 /**
 * This visitor collects information about translation of a lambda expression.
 * More specifically, it keeps track of the enclosing contexts and captured locals
 * accessed by the lambda being translated (as well as other useful info).
+* It also translates away problems for LambdaToMethod.
 */
-class LambdaAnalyzer extends TreeScanner {
+class LambdaAnalyzerPreprocessor extends TreeTranslator {
 /** the frame stack - used to reconstruct translation info about enclosing scopes */
 private List<Frame> frameStack;
 /**
 * a static var init context
 */
 private Map<ClassSymbol, Symbol> clinits =
 new HashMap<ClassSymbol, Symbol>();
-private void analyzeClass(JCClassDecl tree) {
+private JCClassDecl analyzeAndPreprocessClass(JCClassDecl tree) {
 frameStack = List.nil();
 localClassDefs = new HashMap<Symbol, JCClassDecl>();
-scan(tree);
+return translate(tree);
 }
 @Override
 public void visitBlock(JCBlock tree) {
 List<Frame> prevStack = frameStack;
 for (JCVariableDecl param : tree.params) {
 context.addSymbol(param.sym, PARAM);
 frameStack.head.addLocal(param.sym);
 }
 contextMap.put(tree, context);
-scan(tree.body);
+super.visitLambda(tree);
 context.complete();
 }
 finally {
 frameStack = prevStack;
 }
 }
 }
 };
 fvc.scan(localCDef);
 }
 }
+/**
+* Method references to local class constructors, may, if the local
+* class references local variables, have implicit constructor
+* parameters added in Lower; As a result, the invokedynamic bootstrap
+* information added in the LambdaToMethod pass will have the wrong
+* signature. Hooks between Lower and LambdaToMethod have been added to
+* handle normal "new" in this case. This visitor converts potentially
+* effected method references into a lambda containing a normal "new" of
+* the class.
+*
+* @param tree
+*/
 @Override
 public void visitReference(JCMemberReference tree) {
-scan(tree.getQualifierExpression());
+if (tree.getMode() == ReferenceMode.NEW
-contextMap.put(tree, makeReferenceContext(tree));
+&& tree.kind != ReferenceKind.ARRAY_CTOR
+&& tree.sym.owner.isLocal()) {
+MethodSymbol consSym = (MethodSymbol) tree.sym;
+List<Type> ptypes = ((MethodType) consSym.type).getParameterTypes();
+Type classType = consSym.owner.type;
+// Make new-class call
+List<JCVariableDecl> params = make.Params(ptypes, owner());
+JCNewClass nc = makeNewClass(classType, make.Idents(params));
+nc.pos = tree.pos;
+// Make lambda holding the new-class call
+JCLambda slam = make.Lambda(params, nc);
+slam.descriptorType = tree.descriptorType;
+slam.targets = tree.targets;
+slam.type = tree.type;
+slam.pos = tree.pos;
+// Now it is a lambda, process as such
+visitLambda(slam);
+} else {
+super.visitReference(tree);
+contextMap.put(tree, makeReferenceContext(tree));
+}
 }
 @Override
 public void visitSelect(JCFieldAccess tree) {
 if (context() != null && lambdaSelectSymbolFilter(tree.sym)) {
 if (clazz == null) break;
 ((LambdaTranslationContext)localContext).addSymbol(clazz.sym, CAPTURED_THIS);
 }
 localContext = localContext.prev;
 }
-scan(tree.selected);
+}
-} else {
+super.visitSelect(tree);
-super.visitSelect(tree);
-}
 }
 @Override
 public void visitVarDef(JCVariableDecl tree) {
 TranslationContext<?> context = context();

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

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

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