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

8005854: Add support for array constructor references
Summary: Support constructor references of the kind int[]::new
Reviewed-by: jjg

     1 /*

     2  * Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package com.sun.tools.javac.comp;

    27 import com.sun.tools.javac.tree.*;

    28 import com.sun.tools.javac.tree.JCTree;

    29 import com.sun.tools.javac.tree.JCTree.*;

    30 import com.sun.tools.javac.tree.JCTree.JCMemberReference.ReferenceKind;

    31 import com.sun.tools.javac.tree.TreeMaker;

    32 import com.sun.tools.javac.tree.TreeScanner;

    33 import com.sun.tools.javac.tree.TreeTranslator;

    34 import com.sun.tools.javac.code.Flags;

    35 import com.sun.tools.javac.code.Kinds;

    36 import com.sun.tools.javac.code.Symbol;

    37 import com.sun.tools.javac.code.Symbol.ClassSymbol;

    38 import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol;

    39 import com.sun.tools.javac.code.Symbol.MethodSymbol;

    40 import com.sun.tools.javac.code.Symbol.VarSymbol;

    41 import com.sun.tools.javac.code.Symtab;

    42 import com.sun.tools.javac.code.Type;

    43 import com.sun.tools.javac.code.Type.ClassType;

    44 import com.sun.tools.javac.code.Type.MethodType;

    45 import com.sun.tools.javac.code.Types;

    46 import com.sun.tools.javac.comp.LambdaToMethod.LambdaAnalyzer.*;

    47 import com.sun.tools.javac.jvm.*;

    48 import com.sun.tools.javac.util.*;

    49 import com.sun.tools.javac.util.List;

    50 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

    51 import com.sun.source.tree.MemberReferenceTree.ReferenceMode;

    53 import java.util.HashMap;

    54 import java.util.LinkedHashMap;

    55 import java.util.Map;

    57 import static com.sun.tools.javac.comp.LambdaToMethod.LambdaSymbolKind.*;

    58 import static com.sun.tools.javac.code.Flags.*;

    59 import static com.sun.tools.javac.code.Kinds.*;

    60 import static com.sun.tools.javac.code.TypeTag.BOT;

    61 import static com.sun.tools.javac.code.TypeTag.NONE;

    62 import static com.sun.tools.javac.code.TypeTag.VOID;

    63 import static com.sun.tools.javac.tree.JCTree.Tag.*;

    65 /**

    66  * This pass desugars lambda expressions into static methods

    67  *

    68  *  <p><b>This is NOT part of any supported API.

    69  *  If you write code that depends on this, you do so at your own risk.

    70  *  This code and its internal interfaces are subject to change or

    71  *  deletion without notice.</b>

    72  */

    73 public class LambdaToMethod extends TreeTranslator {

    75     private Names names;

    76     private Symtab syms;

    77     private Resolve rs;

    78     private TreeMaker make;

    79     private Types types;

    80     private TransTypes transTypes;

    81     private Env<AttrContext> attrEnv;

    83     /** the analyzer scanner */

    84     private LambdaAnalyzer analyzer;

    86     /** map from lambda trees to translation contexts */

    87     private Map<JCTree, TranslationContext<?>> contextMap;

    89     /** current translation context (visitor argument) */

    90     private TranslationContext<?> context;

    92     /** list of translated methods

    93      **/

    94     private ListBuffer<JCTree> translatedMethodList;

    96     // <editor-fold defaultstate="collapsed" desc="Instantiating">

    97     private static final Context.Key<LambdaToMethod> unlambdaKey =

    98             new Context.Key<LambdaToMethod>();

   100     public static LambdaToMethod instance(Context context) {

   101         LambdaToMethod instance = context.get(unlambdaKey);

   102         if (instance == null) {

   103             instance = new LambdaToMethod(context);

   104         }

   105         return instance;

   106     }

   108     private LambdaToMethod(Context context) {

   109         names = Names.instance(context);

   110         syms = Symtab.instance(context);

   111         rs = Resolve.instance(context);

   112         make = TreeMaker.instance(context);

   113         types = Types.instance(context);

   114         transTypes = TransTypes.instance(context);

   115         this.analyzer = makeAnalyzer();

   116     }

   118     private LambdaAnalyzer makeAnalyzer() {

   119         return new LambdaAnalyzer();

   120     }

   121     // </editor-fold>

   123     // <editor-fold defaultstate="collapsed" desc="translate methods">

   124     @Override

   125     public <T extends JCTree> T translate(T tree) {

   126         TranslationContext<?> newContext = contextMap.get(tree);

   127         return translate(tree, newContext != null ? newContext : context);

   128     }

   130     public <T extends JCTree> T translate(T tree, TranslationContext<?> newContext) {

   131         TranslationContext<?> prevContext = context;

   132         try {

   133             context = newContext;

   134             return super.translate(tree);

   135         }

   136         finally {

   137             context = prevContext;

   138         }

   139     }

   141     public <T extends JCTree> List<T> translate(List<T> trees, TranslationContext<?> newContext) {

   142         ListBuffer<T> buf = ListBuffer.lb();

   143         for (T tree : trees) {

   144             buf.append(translate(tree, newContext));

   145         }

   146         return buf.toList();

   147     }

   149     public JCTree translateTopLevelClass(Env<AttrContext> env, JCTree cdef, TreeMaker make) {

   150         this.make = make;

   151         this.attrEnv = env;

   152         this.context = null;

   153         this.contextMap = new HashMap<JCTree, TranslationContext<?>>();

   154         return translate(cdef);

   155     }

   156     // </editor-fold>

   158     // <editor-fold defaultstate="collapsed" desc="visitor methods">

   159     /**

   160      * Visit a class.

   161      * Maintain the translatedMethodList across nested classes.

   162      * Append the translatedMethodList to the class after it is translated.

   163      * @param tree

   164      */

   165     @Override

   166     public void visitClassDef(JCClassDecl tree) {

   167         if (tree.sym.owner.kind == PCK) {

   168             //analyze class

   169             analyzer.analyzeClass(tree);

   170         }

   171         ListBuffer<JCTree> prevTranslated = translatedMethodList;

   172         try {

   173             translatedMethodList = ListBuffer.lb();

   174             super.visitClassDef(tree);

   175             //add all translated instance methods here

   176             tree.defs = tree.defs.appendList(translatedMethodList.toList());

   177             for (JCTree lambda : translatedMethodList) {

   178                 tree.sym.members().enter(((JCMethodDecl)lambda).sym);

   179             }

   180             result = tree;

   181         } finally {

   182             translatedMethodList = prevTranslated;

   183         }

   184     }

   186     /**

   187      * Translate a lambda into a method to be inserted into the class.

   188      * Then replace the lambda site with an invokedynamic call of to lambda

   189      * meta-factory, which will use the lambda method.

   190      * @param tree

   191      */

   192     @Override

   193     public void visitLambda(JCLambda tree) {

   194         LambdaTranslationContext localContext = (LambdaTranslationContext)context;

   195         MethodSymbol sym = (MethodSymbol)localContext.translatedSym;

   196         MethodType lambdaType = (MethodType) sym.type;

   198         //create the method declaration hoisting the lambda body

   199         JCMethodDecl lambdaDecl = make.MethodDef(make.Modifiers(sym.flags_field),

   200                 sym.name,

   201                 make.QualIdent(lambdaType.getReturnType().tsym),

   202                 List.<JCTypeParameter>nil(),

   203                 localContext.syntheticParams,

   204                 lambdaType.getThrownTypes() == null ?

   205                     List.<JCExpression>nil() :

   206                     make.Types(lambdaType.getThrownTypes()),

   207                 null,

   208                 null);

   209         lambdaDecl.sym = sym;

   210         lambdaDecl.type = lambdaType;

   212         //translate lambda body

   213         //As the lambda body is translated, all references to lambda locals,

   214         //captured variables, enclosing members are adjusted accordingly

   215         //to refer to the static method parameters (rather than i.e. acessing to

   216         //captured members directly).

   217         lambdaDecl.body = translate(makeLambdaBody(tree, lambdaDecl));

   219         //Add the method to the list of methods to be added to this class.

   220         translatedMethodList = translatedMethodList.prepend(lambdaDecl);

   222         //now that we have generated a method for the lambda expression,

   223         //we can translate the lambda into a method reference pointing to the newly

   224         //created method.

   225         //

   226         //Note that we need to adjust the method handle so that it will match the

   227         //signature of the SAM descriptor - this means that the method reference

   228         //should be added the following synthetic arguments:

   229         //

   230         // * the "this" argument if it is an instance method

   231         // * enclosing locals captured by the lambda expression

   233         ListBuffer<JCExpression> syntheticInits = ListBuffer.lb();

   235         if (!sym.isStatic()) {

   236             syntheticInits.append(makeThis(

   237                     sym.owner.asType(),

   238                     localContext.owner.enclClass()));

   239         }

   241         //add captured locals

   242         for (Symbol fv : localContext.getSymbolMap(CAPTURED_VAR).keySet()) {

   243             if (fv != localContext.self) {

   244                 JCTree captured_local = make.Ident(fv).setType(fv.type);

   245                 syntheticInits.append((JCExpression) captured_local);

   246             }

   247         }

   249         //then, determine the arguments to the indy call

   250         List<JCExpression> indy_args = translate(syntheticInits.toList(), localContext.prev);

   252         //build a sam instance using an indy call to the meta-factory

   253         int refKind = referenceKind(sym);

   255         //convert to an invokedynamic call

   256         result = makeMetaFactoryIndyCall(tree, tree.targetType, refKind, sym, indy_args);

   257     }

   259     private JCIdent makeThis(Type type, Symbol owner) {

   260         VarSymbol _this = new VarSymbol(PARAMETER | FINAL | SYNTHETIC,

   261                 names._this,

   262                 type,

   263                 owner);

   264         return make.Ident(_this);

   265     }

   267     /**

   268      * Translate a method reference into an invokedynamic call to the

   269      * meta-factory.

   270      * @param tree

   271      */

   272     @Override

   273     public void visitReference(JCMemberReference tree) {

   274         ReferenceTranslationContext localContext = (ReferenceTranslationContext)context;

   276         //first determine the method symbol to be used to generate the sam instance

   277         //this is either the method reference symbol, or the bridged reference symbol

   278         Symbol refSym = localContext.needsBridge() ?

   279             localContext.bridgeSym :

   280             tree.sym;

   282         //build the bridge method, if needed

   283         if (localContext.needsBridge()) {

   284             bridgeMemberReference(tree, localContext);

   285         }

   287         //the qualifying expression is treated as a special captured arg

   288         JCExpression init;

   289         switch(tree.kind) {

   291             case IMPLICIT_INNER:    /** Inner :: new */

   292             case SUPER:             /** super :: instMethod */

   293                 init = makeThis(

   294                     localContext.owner.owner.asType(),

   295                     localContext.owner);

   296                 break;

   298             case BOUND:             /** Expr :: instMethod */

   299                 init = tree.getQualifierExpression();

   300                 break;

   302             case UNBOUND:           /** Type :: instMethod */

   303             case STATIC:            /** Type :: staticMethod */

   304             case TOPLEVEL:          /** Top level :: new */

   305             case ARRAY_CTOR:        /** ArrayType :: new */

   306                 init = null;

   307                 break;

   309             default:

   310                 throw new InternalError("Should not have an invalid kind");

   311         }

   313         List<JCExpression> indy_args = init==null? List.<JCExpression>nil() : translate(List.of(init), localContext.prev);

   316         //build a sam instance using an indy call to the meta-factory

   317         result = makeMetaFactoryIndyCall(tree, tree.targetType, localContext.referenceKind(), refSym, indy_args);

   318     }

   320     /**

   321      * Translate identifiers within a lambda to the mapped identifier

   322      * @param tree

   323      */

   324     @Override

   325     public void visitIdent(JCIdent tree) {

   326         if (context == null || !analyzer.lambdaIdentSymbolFilter(tree.sym)) {

   327             super.visitIdent(tree);

   328         } else {

   329             LambdaTranslationContext lambdaContext = (LambdaTranslationContext) context;

   330             if (lambdaContext.getSymbolMap(PARAM).containsKey(tree.sym)) {

   331                 Symbol translatedSym = lambdaContext.getSymbolMap(PARAM).get(tree.sym);

   332                 result = make.Ident(translatedSym).setType(tree.type);

   333             } else if (lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {

   334                 Symbol translatedSym = lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym);

   335                 result = make.Ident(translatedSym).setType(tree.type);

   336             } else if (lambdaContext.getSymbolMap(CAPTURED_VAR).containsKey(tree.sym)) {

   337                 Symbol translatedSym = lambdaContext.getSymbolMap(CAPTURED_VAR).get(tree.sym);

   338                 result = make.Ident(translatedSym).setType(tree.type);

   339             } else {

   340                 if (tree.sym.owner.kind == Kinds.TYP) {

   341                     for (Map.Entry<Symbol, Symbol> encl_entry : lambdaContext.getSymbolMap(CAPTURED_THIS).entrySet()) {

   342                         if (tree.sym.isMemberOf((ClassSymbol) encl_entry.getKey(), types)) {

   343                             JCExpression enclRef = make.Ident(encl_entry.getValue());

   344                             result = tree.sym.name == names._this

   345                                     ? enclRef.setType(tree.type)

   346                                     : make.Select(enclRef, tree.sym).setType(tree.type);

   347                             result = tree;

   348                             return;

   349                         }

   350                     }

   351                 }

   352                 //access to untranslated symbols (i.e. compile-time constants,

   353                 //members defined inside the lambda body, etc.) )

   354                 super.visitIdent(tree);

   355             }

   356         }

   357     }

   359     @Override

   360     public void visitVarDef(JCVariableDecl tree) {

   361         LambdaTranslationContext lambdaContext = (LambdaTranslationContext)context;

   362         if (context != null && lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {

   363             JCExpression init = translate(tree.init);

   364             result = make.VarDef((VarSymbol)lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym), init);

   365         } else {

   366             super.visitVarDef(tree);

   367         }

   368     }

   370     // </editor-fold>

   372     // <editor-fold defaultstate="collapsed" desc="Translation helper methods">

   374     private JCBlock makeLambdaBody(JCLambda tree, JCMethodDecl lambdaMethodDecl) {

   375         return tree.getBodyKind() == JCLambda.BodyKind.EXPRESSION ?

   376                 makeLambdaExpressionBody((JCExpression)tree.body, lambdaMethodDecl) :

   377                 makeLambdaStatementBody((JCBlock)tree.body, lambdaMethodDecl, tree.canCompleteNormally);

   378     }

   380     private JCBlock makeLambdaExpressionBody(JCExpression expr, JCMethodDecl lambdaMethodDecl) {

   381         Type restype = lambdaMethodDecl.type.getReturnType();

   382         boolean isLambda_void = expr.type.hasTag(VOID);

   383         boolean isTarget_void = restype.hasTag(VOID);

   384         boolean isTarget_Void = types.isSameType(restype, types.boxedClass(syms.voidType).type);

   385         if (isTarget_void) {

   386             //target is void:

   387             // BODY;

   388             JCStatement stat = make.Exec(expr);

   389             return make.Block(0, List.<JCStatement>of(stat));

   390         } else if (isLambda_void && isTarget_Void) {

   391             //void to Void conversion:

   392             // BODY; return null;

   393             ListBuffer<JCStatement> stats = ListBuffer.lb();

   394             stats.append(make.Exec(expr));

   395             stats.append(make.Return(make.Literal(BOT, null).setType(syms.botType)));

   396             return make.Block(0, stats.toList());

   397         } else {

   398             //non-void to non-void conversion:

   399             // return (TYPE)BODY;

   400             JCExpression retExpr = transTypes.coerce(attrEnv, expr, restype);

   401             return make.Block(0, List.<JCStatement>of(make.Return(retExpr)));

   402         }

   403     }

   405     private JCBlock makeLambdaStatementBody(JCBlock block, final JCMethodDecl lambdaMethodDecl, boolean completeNormally) {

   406         final Type restype = lambdaMethodDecl.type.getReturnType();

   407         final boolean isTarget_void = restype.hasTag(VOID);

   408         boolean isTarget_Void = types.isSameType(restype, types.boxedClass(syms.voidType).type);

   410         class LambdaBodyTranslator extends TreeTranslator {

   412             @Override

   413             public void visitClassDef(JCClassDecl tree) {

   414                 //do NOT recurse on any inner classes

   415                 result = tree;

   416             }

   418             @Override

   419             public void visitLambda(JCLambda tree) {

   420                 //do NOT recurse on any nested lambdas

   421                 result = tree;

   422             }

   424             @Override

   425             public void visitReturn(JCReturn tree) {

   426                 boolean isLambda_void = tree.expr == null;

   427                 if (isTarget_void && !isLambda_void) {

   428                     //Void to void conversion:

   429                     // { TYPE $loc = RET-EXPR; return; }

   430                     VarSymbol loc = makeSyntheticVar(0, names.fromString("$loc"), tree.expr.type, lambdaMethodDecl.sym);

   431                     JCVariableDecl varDef = make.VarDef(loc, tree.expr);

   432                     result = make.Block(0, List.<JCStatement>of(varDef, make.Return(null)));

   433                 } else if (!isTarget_void || !isLambda_void) {

   434                     //non-void to non-void conversion:

   435                     // return (TYPE)RET-EXPR;

   436                     tree.expr = transTypes.coerce(attrEnv, tree.expr, restype);

   437                     result = tree;

   438                 } else {

   439                     result = tree;

   440                 }

   442             }

   443         }

   445         JCBlock trans_block = new LambdaBodyTranslator().translate(block);

   446         if (completeNormally && isTarget_Void) {

   447             //there's no return statement and the lambda (possibly inferred)

   448             //return type is java.lang.Void; emit a synthetic return statement

   449             trans_block.stats = trans_block.stats.append(make.Return(make.Literal(BOT, null).setType(syms.botType)));

   450         }

   451         return trans_block;

   452     }

   454     /**

   455      * Create new synthetic method with given flags, name, type, owner

   456      */

   457     private MethodSymbol makeSyntheticMethod(long flags, Name name, Type type, Symbol owner) {

   458         return new MethodSymbol(flags | SYNTHETIC, name, type, owner);

   459     }

   461     /**

   462      * Create new synthetic variable with given flags, name, type, owner

   463      */

   464     private VarSymbol makeSyntheticVar(long flags, String name, Type type, Symbol owner) {

   465         return makeSyntheticVar(flags, names.fromString(name), type, owner);

   466     }

   468     /**

   469      * Create new synthetic variable with given flags, name, type, owner

   470      */

   471     private VarSymbol makeSyntheticVar(long flags, Name name, Type type, Symbol owner) {

   472         return new VarSymbol(flags | SYNTHETIC, name, type, owner);

   473     }

   475     /**

   476      * Set varargsElement field on a given tree (must be either a new class tree

   477      * or a method call tree)

   478      */

   479     private void setVarargsIfNeeded(JCTree tree, Type varargsElement) {

   480         if (varargsElement != null) {

   481             switch (tree.getTag()) {

   482                 case APPLY: ((JCMethodInvocation)tree).varargsElement = varargsElement; break;

   483                 case NEWCLASS: ((JCNewClass)tree).varargsElement = varargsElement; break;

   484                 default: throw new AssertionError();

   485             }

   486         }

   487     }

   489     /**

   490      * Convert method/constructor arguments by inserting appropriate cast

   491      * as required by type-erasure - this is needed when bridging a lambda/method

   492      * reference, as the bridged signature might require downcast to be compatible

   493      * with the generated signature.

   494      */

   495     private List<JCExpression> convertArgs(Symbol meth, List<JCExpression> args, Type varargsElement) {

   496        Assert.check(meth.kind == Kinds.MTH);

   497        List<Type> formals = types.erasure(meth.type).getParameterTypes();

   498        if (varargsElement != null) {

   499            Assert.check((meth.flags() & VARARGS) != 0);

   500        }

   501        return transTypes.translateArgs(args, formals, varargsElement, attrEnv);

   502     }

   504     // </editor-fold>

   506     private MethodSymbol makeSamDescriptor(Type targetType) {

   507         return (MethodSymbol)types.findDescriptorSymbol(targetType.tsym);

   508     }

   510     private Type makeFunctionalDescriptorType(Type targetType, MethodSymbol samDescriptor, boolean erased) {

   511         Type descType = types.memberType(targetType, samDescriptor);

   512         return erased ? types.erasure(descType) : descType;

   513     }

   515     private Type makeFunctionalDescriptorType(Type targetType, boolean erased) {

   516         return makeFunctionalDescriptorType(targetType, makeSamDescriptor(targetType), erased);

   517     }

   519     /**

   520      * Generate an adapter method "bridge" for a method reference which cannot

   521      * be used directly.

   522      */

   523     private class MemberReferenceBridger {

   525         private final JCMemberReference tree;

   526         private final ReferenceTranslationContext localContext;

   527         private final ListBuffer<JCExpression> args = ListBuffer.lb();

   528         private final ListBuffer<JCVariableDecl> params = ListBuffer.lb();

   530         MemberReferenceBridger(JCMemberReference tree, ReferenceTranslationContext localContext) {

   531             this.tree = tree;

   532             this.localContext = localContext;

   533         }

   535         /**

   536          * Generate the bridge

   537          */

   538         JCMethodDecl bridge() {

   539             int prevPos = make.pos;

   540             try {

   541                 make.at(tree);

   542                 Type samDesc = localContext.bridgedRefSig();

   543                 List<Type> samPTypes = samDesc.getParameterTypes();

   545                 //an extra argument is prepended to the signature of the bridge in case

   546                 //the member reference is an instance method reference (in which case

   547                 //the receiver expression is passed to the bridge itself).

   548                 Type recType = null;

   549                 switch (tree.kind) {

   550                     case IMPLICIT_INNER:

   551                         recType = tree.sym.owner.type.getEnclosingType();

   552                         break;

   553                     case BOUND:

   554                         recType = tree.getQualifierExpression().type;

   555                         break;

   556                     case UNBOUND:

   557                         recType = samPTypes.head;

   558                         samPTypes = samPTypes.tail;

   559                         break;

   560                 }

   562                 //generate the parameter list for the bridged member reference - the

   563                 //bridge signature will match the signature of the target sam descriptor

   565                 VarSymbol rcvr = (recType == null)

   566                         ? null

   567                         : addParameter("rec$", recType, false);

   569                 List<Type> refPTypes = tree.sym.type.getParameterTypes();

   570                 int refSize = refPTypes.size();

   571                 int samSize = samPTypes.size();

   572                 int last = localContext.needsVarArgsConversion() ? refSize - 1 : refSize;   // Last parameter to copy from referenced method

   574                 List<Type> l = refPTypes;

   575                 // Use parameter types of the referenced method, excluding final var args

   576                 for (int i = 0; l.nonEmpty() && i < last; ++i) {

   577                     addParameter("x$" + i, l.head, true);

   578                     l = l.tail;

   579                 }

   580                 // Flatten out the var args

   581                 for (int i = last; i < samSize; ++i) {

   582                     addParameter("xva$" + i, tree.varargsElement, true);

   583                 }

   585                 //generate the bridge method declaration

   586                 JCMethodDecl bridgeDecl = make.MethodDef(make.Modifiers(localContext.bridgeSym.flags()),

   587                         localContext.bridgeSym.name,

   588                         make.QualIdent(samDesc.getReturnType().tsym),

   589                         List.<JCTypeParameter>nil(),

   590                         params.toList(),

   591                         tree.sym.type.getThrownTypes() == null

   592                         ? List.<JCExpression>nil()

   593                         : make.Types(tree.sym.type.getThrownTypes()),

   594                         null,

   595                         null);

   596                 bridgeDecl.sym = (MethodSymbol) localContext.bridgeSym;

   597                 bridgeDecl.type = localContext.bridgeSym.type = types.createMethodTypeWithParameters(samDesc, TreeInfo.types(params.toList()));

   599                 //bridge method body generation - this can be either a method call or a

   600                 //new instance creation expression, depending on the member reference kind

   601                 JCExpression bridgeExpr = (tree.getMode() == ReferenceMode.INVOKE)

   602                         ? bridgeExpressionInvoke(rcvr)

   603                         : bridgeExpressionNew();

   605                 //the body is either a return expression containing a method call,

   606                 //or the method call itself, depending on whether the return type of

   607                 //the bridge is non-void/void.

   608                 bridgeDecl.body = makeLambdaExpressionBody(bridgeExpr, bridgeDecl);

   610                 return bridgeDecl;

   611             } finally {

   612                 make.at(prevPos);

   613             }

   614         }

   616         /**

   617          * determine the receiver of the bridged method call - the receiver can

   618          * be either the synthetic receiver parameter or a type qualifier; the

   619          * original qualifier expression is never used here, as it might refer

   620          * to symbols not available in the static context of the bridge

   621          */

   622         private JCExpression bridgeExpressionInvoke(VarSymbol rcvr) {

   623             JCExpression qualifier =

   624                     tree.sym.isStatic() ?

   625                         make.Type(tree.sym.owner.type) :

   626                         (rcvr != null) ?

   627                             make.Ident(rcvr) :

   628                             tree.getQualifierExpression();

   630             //create the qualifier expression

   631             JCFieldAccess select = make.Select(qualifier, tree.sym.name);

   632             select.sym = tree.sym;

   633             select.type = tree.sym.erasure(types);

   635             //create the method call expression

   636             JCExpression apply = make.Apply(List.<JCExpression>nil(), select,

   637                     convertArgs(tree.sym, args.toList(), tree.varargsElement)).setType(tree.sym.erasure(types).getReturnType());

   639             apply = transTypes.coerce(apply, localContext.generatedRefSig().getReturnType());

   640             setVarargsIfNeeded(apply, tree.varargsElement);

   641             return apply;

   642         }

   644         /**

   645          * the enclosing expression is either 'null' (no enclosing type) or set

   646          * to the first bridge synthetic parameter

   647          */

   648         private JCExpression bridgeExpressionNew() {

   649             if (tree.kind == ReferenceKind.ARRAY_CTOR) {

   650                 //create the array creation expression

   651                 JCNewArray newArr = make.NewArray(make.Type(types.elemtype(tree.getQualifierExpression().type)),

   652                         List.of(make.Ident(params.first())),

   653                         null);

   654                 newArr.type = tree.getQualifierExpression().type;

   655                 return newArr;

   656             } else {

   657                 JCExpression encl = null;

   658                 switch (tree.kind) {

   659                     case UNBOUND:

   660                     case IMPLICIT_INNER:

   661                         encl = make.Ident(params.first());

   662                 }

   664                 //create the instance creation expression

   665                 JCNewClass newClass = make.NewClass(encl,

   666                         List.<JCExpression>nil(),

   667                         make.Type(tree.getQualifierExpression().type),

   668                         convertArgs(tree.sym, args.toList(), tree.varargsElement),

   669                         null);

   670                 newClass.constructor = tree.sym;

   671                 newClass.constructorType = tree.sym.erasure(types);

   672                 newClass.type = tree.getQualifierExpression().type;

   673                 setVarargsIfNeeded(newClass, tree.varargsElement);

   674                 return newClass;

   675             }

   676         }

   678         private VarSymbol addParameter(String name, Type p, boolean genArg) {

   679             VarSymbol vsym = new VarSymbol(0, names.fromString(name), p, localContext.bridgeSym);

   680             params.append(make.VarDef(vsym, null));

   681             if (genArg) {

   682                 args.append(make.Ident(vsym));

   683             }

   684             return vsym;

   685         }

   686     }

   688     /**

   689      * Bridges a member reference - this is needed when:

   690      * * Var args in the referenced method need to be flattened away

   691      * * super is used

   692      */

   693     private void bridgeMemberReference(JCMemberReference tree, ReferenceTranslationContext localContext) {

   694         JCMethodDecl bridgeDecl = (new MemberReferenceBridger(tree, localContext).bridge());

   695         translatedMethodList = translatedMethodList.prepend(bridgeDecl);

   696     }

   698     /**

   699      * Generate an indy method call to the meta factory

   700      */

   701     private JCExpression makeMetaFactoryIndyCall(JCExpression tree, Type targetType, int refKind, Symbol refSym, List<JCExpression> indy_args) {

   702         //determine the static bsm args

   703         Type mtype = makeFunctionalDescriptorType(targetType, true);

   704         List<Object> staticArgs = List.<Object>of(

   705                 new Pool.MethodHandle(ClassFile.REF_invokeInterface,

   706                     types.findDescriptorSymbol(targetType.tsym), types),

   707                 new Pool.MethodHandle(refKind, refSym, types),

   708                 new MethodType(mtype.getParameterTypes(),

   709                         mtype.getReturnType(),

   710                         mtype.getThrownTypes(),

   711                         syms.methodClass));

   713         //computed indy arg types

   714         ListBuffer<Type> indy_args_types = ListBuffer.lb();

   715         for (JCExpression arg : indy_args) {

   716             indy_args_types.append(arg.type);

   717         }

   719         //finally, compute the type of the indy call

   720         MethodType indyType = new MethodType(indy_args_types.toList(),

   721                 tree.type,

   722                 List.<Type>nil(),

   723                 syms.methodClass);

   725         return makeIndyCall(tree, syms.lambdaMetafactory, names.metaFactory, staticArgs, indyType, indy_args);

   726     }

   728     /**

   729      * Generate an indy method call with given name, type and static bootstrap

   730      * arguments types

   731      */

   732     private JCExpression makeIndyCall(DiagnosticPosition pos, Type site, Name bsmName, List<Object> staticArgs, MethodType indyType, List<JCExpression> indyArgs) {

   733         int prevPos = make.pos;

   734         try {

   735             make.at(pos);

   736             List<Type> bsm_staticArgs = List.of(syms.methodHandleLookupType,

   737                     syms.stringType,

   738                     syms.methodTypeType).appendList(bsmStaticArgToTypes(staticArgs));

   740             Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site,

   741                     bsmName, bsm_staticArgs, List.<Type>nil());

   743             DynamicMethodSymbol dynSym =

   744                     new DynamicMethodSymbol(names.lambda,

   745                                             syms.noSymbol,

   746                                             bsm.isStatic() ? ClassFile.REF_invokeStatic : ClassFile.REF_invokeVirtual,

   747                                             (MethodSymbol)bsm,

   748                                             indyType,

   749                                             staticArgs.toArray());

   751             JCFieldAccess qualifier = make.Select(make.QualIdent(site.tsym), bsmName);

   752             qualifier.sym = dynSym;

   753             qualifier.type = indyType.getReturnType();

   755             JCMethodInvocation proxyCall = make.Apply(List.<JCExpression>nil(), qualifier, indyArgs);

   756             proxyCall.type = indyType.getReturnType();

   757             return proxyCall;

   758         } finally {

   759             make.at(prevPos);

   760         }

   761     }

   762     //where

   763     private List<Type> bsmStaticArgToTypes(List<Object> args) {

   764         ListBuffer<Type> argtypes = ListBuffer.lb();

   765         for (Object arg : args) {

   766             argtypes.append(bsmStaticArgToType(arg));

   767         }

   768         return argtypes.toList();

   769     }

   771     private Type bsmStaticArgToType(Object arg) {

   772         Assert.checkNonNull(arg);

   773         if (arg instanceof ClassSymbol) {

   774             return syms.classType;

   775         } else if (arg instanceof Integer) {

   776             return syms.intType;

   777         } else if (arg instanceof Long) {

   778             return syms.longType;

   779         } else if (arg instanceof Float) {

   780             return syms.floatType;

   781         } else if (arg instanceof Double) {

   782             return syms.doubleType;

   783         } else if (arg instanceof String) {

   784             return syms.stringType;

   785         } else if (arg instanceof Pool.MethodHandle) {

   786             return syms.methodHandleType;

   787         } else if (arg instanceof MethodType) {

   788             return syms.methodTypeType;

   789         } else {

   790             Assert.error("bad static arg " + arg.getClass());

   791             return null;

   792         }

   793     }

   795     /**

   796      * Get the opcode associated with this method reference

   797      */

   798     private int referenceKind(Symbol refSym) {

   799         if (refSym.isConstructor()) {

   800             return ClassFile.REF_newInvokeSpecial;

   801         } else {

   802             if (refSym.isStatic()) {

   803                 return ClassFile.REF_invokeStatic;

   804             } else if (refSym.enclClass().isInterface()) {

   805                 return ClassFile.REF_invokeInterface;

   806             } else {

   807                 return ClassFile.REF_invokeVirtual;

   808             }

   809         }

   810     }

   811     // </editor-fold>

   813     // <editor-fold defaultstate="collapsed" desc="Lambda/reference analyzer">\

   814     /**

   815      * This visitor collects information about translation of a lambda expression.

   816      * More specifically, it keeps track of the enclosing contexts and captured locals

   817      * accessed by the lambda being translated (as well as other useful info).

   818      */

   819     class LambdaAnalyzer extends TreeScanner {

   821         /** the frame stack - used to reconstruct translation info about enclosing scopes */

   822         private List<Frame> frameStack;

   824         /**

   825          * keep the count of lambda expression (used to generate unambiguous

   826          * names)

   827          */

   828         private int lambdaCount = 0;

   830         private void analyzeClass(JCClassDecl tree) {

   831             frameStack = List.nil();

   832             scan(tree);

   833         }

   835         @Override

   836         public void visitBlock(JCBlock tree) {

   837             List<Frame> prevStack = frameStack;

   838             try {

   839                 if (frameStack.nonEmpty() && frameStack.head.tree.hasTag(CLASSDEF)) {

   840                     frameStack = frameStack.prepend(new Frame(tree));

   841                 }

   842                 super.visitBlock(tree);

   843             }

   844             finally {

   845                 frameStack = prevStack;

   846             }

   847         }

   849         @Override

   850         public void visitClassDef(JCClassDecl tree) {

   851             List<Frame> prevStack = frameStack;

   852             try {

   853                 if (frameStack.nonEmpty() && enclosingLambda() != null) {

   854                     tree.sym.owner = owner();

   855                     LambdaTranslationContext lambdaContext = (LambdaTranslationContext)contextMap.get(enclosingLambda());

   856                     Type encl = lambdaContext.enclosingType();

   857                     if (encl.hasTag(NONE)) {

   858                         //if the translated lambda body occurs in a static context,

   859                         //any class declaration within it must be made static

   860                         tree.sym.flags_field |= STATIC;

   861                         ((ClassType)tree.sym.type).setEnclosingType(Type.noType);

   862                     } else {

   863                         //if the translated lambda body is in an instance context

   864                         //the enclosing type of any class declaration within it

   865                         //must be updated to point to the new enclosing type (if any)

   866                         ((ClassType)tree.sym.type).setEnclosingType(encl);

   867                     }

   868                 }

   869                 frameStack = frameStack.prepend(new Frame(tree));

   870                 super.visitClassDef(tree);

   871             }

   872             finally {

   873                 frameStack = prevStack;

   874             }

   875             if (frameStack.nonEmpty() && enclosingLambda() != null) {

   876                 // Any class defined within a lambda is an implicit 'this' reference

   877                 // because its constructor will reference the enclosing class

   878                 ((LambdaTranslationContext) context()).addSymbol(tree.sym.type.getEnclosingType().tsym, CAPTURED_THIS);

   879             }

   880         }

   882         @Override

   883         public void visitIdent(JCIdent tree) {

   884             if (context() == null || !lambdaIdentSymbolFilter(tree.sym)) {

   885                 super.visitIdent(tree);

   886             } else {

   887                 if (tree.sym.kind == VAR &&

   888                         tree.sym.owner.kind == MTH &&

   889                         tree.type.constValue() == null) {

   890                     TranslationContext<?> localContext = context();

   891                     while (localContext != null) {

   892                         if (localContext.tree.getTag() == LAMBDA) {

   893                             JCTree block = capturedDecl(localContext.depth, tree.sym);

   894                             if (block == null) break;

   895                             ((LambdaTranslationContext)localContext).addSymbol(tree.sym, CAPTURED_VAR);

   896                         }

   897                         localContext = localContext.prev;

   898                     }

   899                 } else if (tree.sym.owner.kind == TYP) {

   900                     TranslationContext<?> localContext = context();

   901                     while (localContext != null) {

   902                         if (localContext.tree.hasTag(LAMBDA)) {

   903                             JCTree block = capturedDecl(localContext.depth, tree.sym);

   904                             if (block == null) break;

   905                             switch (block.getTag()) {

   906                                 case CLASSDEF:

   907                                     JCClassDecl cdecl = (JCClassDecl)block;

   908                                     ((LambdaTranslationContext)localContext).addSymbol(cdecl.sym, CAPTURED_THIS);

   909                                     break;

   910                                 default:

   911                                     Assert.error("bad block kind");

   912                             }

   913                         }

   914                         localContext = localContext.prev;

   915                     }

   916                 }

   917             }

   918         }

   920         @Override

   921         public void visitLambda(JCLambda tree) {

   922             List<Frame> prevStack = frameStack;

   923             try {

   924                 LambdaTranslationContext context = (LambdaTranslationContext)makeLambdaContext(tree);

   925                 frameStack = frameStack.prepend(new Frame(tree));

   926                 for (JCVariableDecl param : tree.params) {

   927                     context.addSymbol(param.sym, PARAM);

   928                     frameStack.head.addLocal(param.sym);

   929                 }

   930                 contextMap.put(tree, context);

   931                 scan(tree.body);

   932                 context.complete();

   933             }

   934             finally {

   935                 frameStack = prevStack;

   936             }

   937         }

   939         @Override

   940         public void visitMethodDef(JCMethodDecl tree) {

   941             List<Frame> prevStack = frameStack;

   942             try {

   943                 frameStack = frameStack.prepend(new Frame(tree));

   944                 super.visitMethodDef(tree);

   945             }

   946             finally {

   947                 frameStack = prevStack;

   948             }

   949         }

   951         @Override

   952         public void visitNewClass(JCNewClass tree) {

   953             if (lambdaNewClassFilter(context(), tree)) {

   954                 ((LambdaTranslationContext) context()).addSymbol(tree.type.getEnclosingType().tsym, CAPTURED_THIS);

   955             }

   956             super.visitNewClass(tree);

   957         }

   959         @Override

   960         public void visitReference(JCMemberReference tree) {

   961             scan(tree.getQualifierExpression());

   962             contextMap.put(tree, makeReferenceContext(tree));

   963         }

   965         @Override

   966         public void visitSelect(JCFieldAccess tree) {

   967             if (context() != null && lambdaSelectSymbolFilter(tree.sym)) {

   968                 TranslationContext<?> localContext = context();

   969                 while (localContext != null) {

   970                     if (localContext.tree.hasTag(LAMBDA)) {

   971                         JCClassDecl clazz = (JCClassDecl)capturedDecl(localContext.depth, tree.sym);

   972                         if (clazz == null) break;

   973                         ((LambdaTranslationContext)localContext).addSymbol(clazz.sym, CAPTURED_THIS);

   974                     }

   975                     localContext = localContext.prev;

   976                 }

   977                 scan(tree.selected);

   978             } else {

   979                 super.visitSelect(tree);

   980             }

   981         }

   983         @Override

   984         public void visitVarDef(JCVariableDecl tree) {

   985             if (frameStack.head.tree.hasTag(LAMBDA)) {

   986                 ((LambdaTranslationContext)context()).addSymbol(tree.sym, LOCAL_VAR);

   987             }

   988             List<Frame> prevStack = frameStack;

   989             try {

   990                 if (tree.sym.owner.kind == MTH) {

   991                     frameStack.head.addLocal(tree.sym);

   992                 }

   993                 frameStack = frameStack.prepend(new Frame(tree));

   994                 super.visitVarDef(tree);

   995             }

   996             finally {

   997                 frameStack = prevStack;

   998             }

   999         }

  1001         private Name lambdaName() {

  1002             return names.lambda.append(names.fromString("$" + lambdaCount++));

  1003         }

  1005         /**

  1006          * Return a valid owner given the current declaration stack

  1007          * (required to skip synthetic lambda symbols)

  1008          */

  1009         private Symbol owner() {

  1010             List<Frame> frameStack2 = frameStack;

  1011             while (frameStack2.nonEmpty()) {

  1012                 switch (frameStack2.head.tree.getTag()) {

  1013                     case VARDEF:

  1014                         if (((JCVariableDecl)frameStack2.head.tree).sym.isLocal()) {

  1015                             frameStack2 = frameStack2.tail;

  1016                             break;

  1017                         }

  1018                         JCClassDecl cdecl = (JCClassDecl)frameStack2.tail.head.tree;

  1019                         return makeSyntheticMethod(((JCVariableDecl)frameStack2.head.tree).sym.flags() & STATIC, names.empty, null, cdecl.sym);

  1020                     case BLOCK:

  1021                         JCClassDecl cdecl2 = (JCClassDecl)frameStack2.tail.head.tree;

  1022                         return makeSyntheticMethod(((JCBlock)frameStack2.head.tree).flags & STATIC | Flags.BLOCK, names.empty, null, cdecl2.sym);

  1023                     case CLASSDEF:

  1024                         return ((JCClassDecl)frameStack2.head.tree).sym;

  1025                     case METHODDEF:

  1026                         return ((JCMethodDecl)frameStack2.head.tree).sym;

  1027                     case LAMBDA:

  1028                         return ((LambdaTranslationContext)contextMap.get(frameStack2.head.tree)).translatedSym;

  1029                     default:

  1030                         frameStack2 = frameStack2.tail;

  1031                 }

  1032             }

  1033             Assert.error();

  1034             return null;

  1035         }

  1037         private JCTree enclosingLambda() {

  1038             List<Frame> frameStack2 = frameStack;

  1039             while (frameStack2.nonEmpty()) {

  1040                 switch (frameStack2.head.tree.getTag()) {

  1041                     case CLASSDEF:

  1042                     case METHODDEF:

  1043                         return null;

  1044                     case LAMBDA:

  1045                         return frameStack2.head.tree;

  1046                     default:

  1047                         frameStack2 = frameStack2.tail;

  1048                 }

  1049             }

  1050             Assert.error();

  1051             return null;

  1052         }

  1054         /**

  1055          * Return the declaration corresponding to a symbol in the enclosing

  1056          * scope; the depth parameter is used to filter out symbols defined

  1057          * in nested scopes (which do not need to undergo capture).

  1058          */

  1059         private JCTree capturedDecl(int depth, Symbol sym) {

  1060             int currentDepth = frameStack.size() - 1;

  1061             for (Frame block : frameStack) {

  1062                 switch (block.tree.getTag()) {

  1063                     case CLASSDEF:

  1064                         ClassSymbol clazz = ((JCClassDecl)block.tree).sym;

  1065                         if (sym.isMemberOf(clazz, types)) {

  1066                             return currentDepth > depth ? null : block.tree;

  1067                         }

  1068                         break;

  1069                     case VARDEF:

  1070                         if (((JCVariableDecl)block.tree).sym == sym &&

  1071                                 sym.owner.kind == MTH) { //only locals are captured

  1072                             return currentDepth > depth ? null : block.tree;

  1073                         }

  1074                         break;

  1075                     case BLOCK:

  1076                     case METHODDEF:

  1077                     case LAMBDA:

  1078                         if (block.locals != null && block.locals.contains(sym)) {

  1079                             return currentDepth > depth ? null : block.tree;

  1080                         }

  1081                         break;

  1082                     default:

  1083                         Assert.error("bad decl kind " + block.tree.getTag());

  1084                 }

  1085                 currentDepth--;

  1086             }

  1087             return null;

  1088         }

  1090         private TranslationContext<?> context() {

  1091             for (Frame frame : frameStack) {

  1092                 TranslationContext<?> context = contextMap.get(frame.tree);

  1093                 if (context != null) {

  1094                     return context;

  1095                 }

  1096             }

  1097             return null;

  1098         }

  1100         /**

  1101          *  This is used to filter out those identifiers that needs to be adjusted

  1102          *  when translating away lambda expressions

  1103          */

  1104         private boolean lambdaIdentSymbolFilter(Symbol sym) {

  1105             return (sym.kind == VAR || sym.kind == MTH)

  1106                     && !sym.isStatic()

  1107                     && sym.name != names.init;

  1108         }

  1110         private boolean lambdaSelectSymbolFilter(Symbol sym) {

  1111             return (sym.kind == VAR || sym.kind == MTH) &&

  1112                         !sym.isStatic() &&

  1113                         (sym.name == names._this ||

  1114                         sym.name == names._super);

  1115         }

  1117         /**

  1118          * This is used to filter out those new class expressions that need to

  1119          * be qualified with an enclosing tree

  1120          */

  1121         private boolean lambdaNewClassFilter(TranslationContext<?> context, JCNewClass tree) {

  1122             if (context != null

  1123                     && tree.encl == null

  1124                     && tree.def == null

  1125                     && !tree.type.getEnclosingType().hasTag(NONE)) {

  1126                 Type encl = tree.type.getEnclosingType();

  1127                 Type current = context.owner.enclClass().type;

  1128                 while (!current.hasTag(NONE)) {

  1129                     if (current.tsym.isSubClass(encl.tsym, types)) {

  1130                         return true;

  1131                     }

  1132                     current = current.getEnclosingType();

  1133                 }

  1134                 return false;

  1135             } else {

  1136                 return false;

  1137             }

  1138         }

  1140         private TranslationContext<JCLambda> makeLambdaContext(JCLambda tree) {

  1141             return new LambdaTranslationContext(tree);

  1142         }

  1144         private TranslationContext<JCMemberReference> makeReferenceContext(JCMemberReference tree) {

  1145             return new ReferenceTranslationContext(tree);

  1146         }

  1148         private class Frame {

  1149             final JCTree tree;

  1150             List<Symbol> locals;

  1152             public Frame(JCTree tree) {

  1153                 this.tree = tree;

  1154             }

  1156             void addLocal(Symbol sym) {

  1157                 if (locals == null) {

  1158                     locals = List.nil();

  1159                 }

  1160                 locals = locals.prepend(sym);

  1161             }

  1162         }

  1164         /**

  1165          * This class is used to store important information regarding translation of

  1166          * lambda expression/method references (see subclasses).

  1167          */

  1168         private abstract class TranslationContext<T extends JCTree> {

  1170             /** the underlying (untranslated) tree */

  1171             T tree;

  1173             /** points to the adjusted enclosing scope in which this lambda/mref expression occurs */

  1174             Symbol owner;

  1176             /** the depth of this lambda expression in the frame stack */

  1177             int depth;

  1179             /** the enclosing translation context (set for nested lambdas/mref) */

  1180             TranslationContext<?> prev;

  1182             TranslationContext(T tree) {

  1183                 this.tree = tree;

  1184                 this.owner = owner();

  1185                 this.depth = frameStack.size() - 1;

  1186                 this.prev = context();

  1187             }

  1188         }

  1190         /**

  1191          * This class retains all the useful information about a lambda expression;

  1192          * the contents of this class are filled by the LambdaAnalyzer visitor,

  1193          * and the used by the main translation routines in order to adjust references

  1194          * to captured locals/members, etc.

  1195          */

  1196         private class LambdaTranslationContext extends TranslationContext<JCLambda> {

  1198             /** variable in the enclosing context to which this lambda is assigned */

  1199             Symbol self;

  1201             /** map from original to translated lambda parameters */

  1202             Map<Symbol, Symbol> lambdaParams = new LinkedHashMap<Symbol, Symbol>();

  1204             /** map from original to translated lambda locals */

  1205             Map<Symbol, Symbol> lambdaLocals = new LinkedHashMap<Symbol, Symbol>();

  1207             /** map from variables in enclosing scope to translated synthetic parameters */

  1208             Map<Symbol, Symbol> capturedLocals  = new LinkedHashMap<Symbol, Symbol>();

  1210             /** map from class symbols to translated synthetic parameters (for captured member access) */

  1211             Map<Symbol, Symbol> capturedThis = new LinkedHashMap<Symbol, Symbol>();

  1213             /** the synthetic symbol for the method hoisting the translated lambda */

  1214             Symbol translatedSym;

  1216             List<JCVariableDecl> syntheticParams;

  1218             LambdaTranslationContext(JCLambda tree) {

  1219                 super(tree);

  1220                 Frame frame = frameStack.head;

  1221                 if (frame.tree.hasTag(VARDEF)) {

  1222                     self = ((JCVariableDecl)frame.tree).sym;

  1223                 }

  1224                 this.translatedSym = makeSyntheticMethod(0, lambdaName(), null, owner.enclClass());

  1225             }

  1227             /**

  1228              * Translate a symbol of a given kind into something suitable for the

  1229              * synthetic lambda body

  1230              */

  1231             Symbol translate(String name, Symbol sym, LambdaSymbolKind skind) {

  1232                 if (skind == CAPTURED_THIS) {

  1233                     return sym;  // self represented

  1234                 } else {

  1235                     return makeSyntheticVar(FINAL, name, types.erasure(sym.type), translatedSym);

  1236                 }

  1237             }

  1239             void addSymbol(Symbol sym, LambdaSymbolKind skind) {

  1240                 Map<Symbol, Symbol> transMap = null;

  1241                 String preferredName;

  1242                 switch (skind) {

  1243                     case CAPTURED_THIS:

  1244                         transMap = capturedThis;

  1245                         preferredName = "encl$" + capturedThis.size();

  1246                         break;

  1247                     case CAPTURED_VAR:

  1248                         transMap = capturedLocals;

  1249                         preferredName = "cap$" + capturedLocals.size();

  1250                         break;

  1251                     case LOCAL_VAR:

  1252                         transMap = lambdaLocals;

  1253                         preferredName = sym.name.toString();

  1254                         break;

  1255                     case PARAM:

  1256                         transMap = lambdaParams;

  1257                         preferredName = sym.name.toString();

  1258                         break;

  1259                     default: throw new AssertionError();

  1260                 }

  1261                 if (!transMap.containsKey(sym)) {

  1262                     transMap.put(sym, translate(preferredName, sym, skind));

  1263                 }

  1264             }

  1266             Map<Symbol, Symbol> getSymbolMap(LambdaSymbolKind... skinds) {

  1267                 LinkedHashMap<Symbol, Symbol> translationMap = new LinkedHashMap<Symbol, Symbol>();

  1268                 for (LambdaSymbolKind skind : skinds) {

  1269                     switch (skind) {

  1270                         case CAPTURED_THIS:

  1271                             translationMap.putAll(capturedThis);

  1272                             break;

  1273                         case CAPTURED_VAR:

  1274                             translationMap.putAll(capturedLocals);

  1275                             break;

  1276                         case LOCAL_VAR:

  1277                             translationMap.putAll(lambdaLocals);

  1278                             break;

  1279                         case PARAM:

  1280                             translationMap.putAll(lambdaParams);

  1281                             break;

  1282                         default: throw new AssertionError();

  1283                     }

  1284                 }

  1285                 return translationMap;

  1286             }

  1288             /**

  1289              * The translatedSym is not complete/accurate until the analysis is

  1290              * finished.  Once the analysis is finished, the translatedSym is

  1291              * "completed" -- updated with type information, access modifiers,

  1292              * and full parameter list.

  1293              */

  1294             void complete() {

  1295                 if (syntheticParams != null) {

  1296                     return;

  1297                 }

  1298                 boolean inInterface = translatedSym.owner.isInterface();

  1299                 boolean thisReferenced = !getSymbolMap(CAPTURED_THIS).isEmpty();

  1300                 boolean needInstance = thisReferenced || inInterface;

  1302                 // If instance access isn't needed, make it static

  1303                 // Interface methods much be public default methods, otherwise make it private

  1304                 translatedSym.flags_field = SYNTHETIC | (needInstance? 0 : STATIC) | (inInterface? PUBLIC | DEFAULT : PRIVATE);

  1306                 //compute synthetic params

  1307                 ListBuffer<JCVariableDecl> params = ListBuffer.lb();

  1309                 // The signature of the method is augmented with the following

  1310                 // synthetic parameters:

  1311                 //

  1312                 // 1) reference to enclosing contexts captured by the lambda expression

  1313                 // 2) enclosing locals captured by the lambda expression

  1314                 for (Symbol thisSym : getSymbolMap(CAPTURED_VAR, PARAM).values()) {

  1315                     params.append(make.VarDef((VarSymbol) thisSym, null));

  1316                 }

  1318                 syntheticParams = params.toList();

  1320                 //prepend synthetic args to translated lambda method signature

  1321                 translatedSym.type = (MethodType) types.createMethodTypeWithParameters(

  1322                         (MethodType) generatedLambdaSig(),

  1323                         TreeInfo.types(syntheticParams));

  1324             }

  1326             Type enclosingType() {

  1327                 //local inner classes defined inside a lambda are always non-static

  1328                 return owner.enclClass().type;

  1329             }

  1331             Type generatedLambdaSig() {

  1332                 return types.erasure(types.findDescriptorType(tree.targetType));

  1333             }

  1334         }

  1336         /**

  1337          * This class retains all the useful information about a method reference;

  1338          * the contents of this class are filled by the LambdaAnalyzer visitor,

  1339          * and the used by the main translation routines in order to adjust method

  1340          * references (i.e. in case a bridge is needed)

  1341          */

  1342         private class ReferenceTranslationContext extends TranslationContext<JCMemberReference> {

  1344             final boolean isSuper;

  1345             final Symbol bridgeSym;

  1347             ReferenceTranslationContext(JCMemberReference tree) {

  1348                 super(tree);

  1349                 this.isSuper = tree.hasKind(ReferenceKind.SUPER);

  1350                 this.bridgeSym = needsBridge()

  1351                         ? makeSyntheticMethod(isSuper ? 0 : STATIC,

  1352                                               lambdaName().append(names.fromString("$bridge")), null,

  1353                                               owner.enclClass())

  1354                         : null;

  1355             }

  1357             /**

  1358              * Get the opcode associated with this method reference

  1359              */

  1360             int referenceKind() {

  1361                 return LambdaToMethod.this.referenceKind(needsBridge() ? bridgeSym : tree.sym);

  1362             }

  1364             boolean needsVarArgsConversion() {

  1365                 return tree.varargsElement != null;

  1366             }

  1368             /**

  1369              * @return Is this an array operation like clone()

  1370              */

  1371             boolean isArrayOp() {

  1372                 return tree.sym.owner == syms.arrayClass;

  1373             }

  1375             /**

  1376              * Does this reference needs a bridge (i.e. var args need to be

  1377              * expanded or "super" is used)

  1378              */

  1379             final boolean needsBridge() {

  1380                 return isSuper || needsVarArgsConversion() || isArrayOp();

  1381             }

  1383             Type generatedRefSig() {

  1384                 return types.erasure(tree.sym.type);

  1385             }

  1387             Type bridgedRefSig() {

  1388                 return types.erasure(types.findDescriptorSymbol(tree.targetType.tsym).type);

  1389             }

  1390         }

  1391     }

  1392     // </editor-fold>

  1394     enum LambdaSymbolKind {

  1395         CAPTURED_VAR,

  1396         CAPTURED_THIS,

  1397         LOCAL_VAR,

  1398         PARAM;

  1399     }

  1400 }

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

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

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