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

8005244: Implement overload resolution as per latest spec EDR
Summary: Add support for stuck expressions and provisional applicability
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, 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, 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     /**

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

   508      * be used directly.

   509      */

   510     private class MemberReferenceBridger {

   512         private final JCMemberReference tree;

   513         private final ReferenceTranslationContext localContext;

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

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

   517         MemberReferenceBridger(JCMemberReference tree, ReferenceTranslationContext localContext) {

   518             this.tree = tree;

   519             this.localContext = localContext;

   520         }

   522         /**

   523          * Generate the bridge

   524          */

   525         JCMethodDecl bridge() {

   526             int prevPos = make.pos;

   527             try {

   528                 make.at(tree);

   529                 Type samDesc = localContext.bridgedRefSig();

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

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

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

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

   535                 Type recType = null;

   536                 switch (tree.kind) {

   537                     case IMPLICIT_INNER:

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

   539                         break;

   540                     case BOUND:

   541                         recType = tree.getQualifierExpression().type;

   542                         break;

   543                     case UNBOUND:

   544                         recType = samPTypes.head;

   545                         samPTypes = samPTypes.tail;

   546                         break;

   547                 }

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

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

   552                 VarSymbol rcvr = (recType == null)

   553                         ? null

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

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

   557                 int refSize = refPTypes.size();

   558                 int samSize = samPTypes.size();

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

   561                 List<Type> l = refPTypes;

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

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

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

   565                     l = l.tail;

   566                 }

   567                 // Flatten out the var args

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

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

   570                 }

   572                 //generate the bridge method declaration

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

   574                         localContext.bridgeSym.name,

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

   576                         List.<JCTypeParameter>nil(),

   577                         params.toList(),

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

   579                         ? List.<JCExpression>nil()

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

   581                         null,

   582                         null);

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

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

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

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

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

   589                         ? bridgeExpressionInvoke(rcvr)

   590                         : bridgeExpressionNew();

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

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

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

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

   597                 return bridgeDecl;

   598             } finally {

   599                 make.at(prevPos);

   600             }

   601         }

   603         /**

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

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

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

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

   608          */

   609         private JCExpression bridgeExpressionInvoke(VarSymbol rcvr) {

   610             JCExpression qualifier =

   611                     tree.sym.isStatic() ?

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

   613                         (rcvr != null) ?

   614                             make.Ident(rcvr) :

   615                             tree.getQualifierExpression();

   617             //create the qualifier expression

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

   619             select.sym = tree.sym;

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

   622             //create the method call expression

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

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

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

   627             setVarargsIfNeeded(apply, tree.varargsElement);

   628             return apply;

   629         }

   631         /**

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

   633          * to the first bridge synthetic parameter

   634          */

   635         private JCExpression bridgeExpressionNew() {

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

   637                 //create the array creation expression

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

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

   640                         null);

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

   642                 return newArr;

   643             } else {

   644                 JCExpression encl = null;

   645                 switch (tree.kind) {

   646                     case UNBOUND:

   647                     case IMPLICIT_INNER:

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

   649                 }

   651                 //create the instance creation expression

   652                 JCNewClass newClass = make.NewClass(encl,

   653                         List.<JCExpression>nil(),

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

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

   656                         null);

   657                 newClass.constructor = tree.sym;

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

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

   660                 setVarargsIfNeeded(newClass, tree.varargsElement);

   661                 return newClass;

   662             }

   663         }

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

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

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

   668             if (genArg) {

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

   670             }

   671             return vsym;

   672         }

   673     }

   675     /**

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

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

   678      * * super is used

   679      */

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

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

   682         translatedMethodList = translatedMethodList.prepend(bridgeDecl);

   683     }

   685     /**

   686      * Generate an indy method call to the meta factory

   687      */

   688     private JCExpression makeMetaFactoryIndyCall(JCFunctionalExpression tree, int refKind, Symbol refSym, List<JCExpression> indy_args) {

   689         //determine the static bsm args

   690         Type mtype = types.erasure(tree.descriptorType);

   691         MethodSymbol samSym = (MethodSymbol) types.findDescriptorSymbol(tree.type.tsym);

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

   693                 new Pool.MethodHandle(ClassFile.REF_invokeInterface, types.findDescriptorSymbol(tree.type.tsym), types),

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

   695                 new MethodType(mtype.getParameterTypes(),

   696                         mtype.getReturnType(),

   697                         mtype.getThrownTypes(),

   698                         syms.methodClass));

   700         //computed indy arg types

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

   702         for (JCExpression arg : indy_args) {

   703             indy_args_types.append(arg.type);

   704         }

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

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

   708                 tree.type,

   709                 List.<Type>nil(),

   710                 syms.methodClass);

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

   713     }

   715     /**

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

   717      * arguments types

   718      */

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

   720         int prevPos = make.pos;

   721         try {

   722             make.at(pos);

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

   724                     syms.stringType,

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

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

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

   730             DynamicMethodSymbol dynSym =

   731                     new DynamicMethodSymbol(names.lambda,

   732                                             syms.noSymbol,

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

   734                                             (MethodSymbol)bsm,

   735                                             indyType,

   736                                             staticArgs.toArray());

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

   739             qualifier.sym = dynSym;

   740             qualifier.type = indyType.getReturnType();

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

   743             proxyCall.type = indyType.getReturnType();

   744             return proxyCall;

   745         } finally {

   746             make.at(prevPos);

   747         }

   748     }

   749     //where

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

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

   752         for (Object arg : args) {

   753             argtypes.append(bsmStaticArgToType(arg));

   754         }

   755         return argtypes.toList();

   756     }

   758     private Type bsmStaticArgToType(Object arg) {

   759         Assert.checkNonNull(arg);

   760         if (arg instanceof ClassSymbol) {

   761             return syms.classType;

   762         } else if (arg instanceof Integer) {

   763             return syms.intType;

   764         } else if (arg instanceof Long) {

   765             return syms.longType;

   766         } else if (arg instanceof Float) {

   767             return syms.floatType;

   768         } else if (arg instanceof Double) {

   769             return syms.doubleType;

   770         } else if (arg instanceof String) {

   771             return syms.stringType;

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

   773             return syms.methodHandleType;

   774         } else if (arg instanceof MethodType) {

   775             return syms.methodTypeType;

   776         } else {

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

   778             return null;

   779         }

   780     }

   782     /**

   783      * Get the opcode associated with this method reference

   784      */

   785     private int referenceKind(Symbol refSym) {

   786         if (refSym.isConstructor()) {

   787             return ClassFile.REF_newInvokeSpecial;

   788         } else {

   789             if (refSym.isStatic()) {

   790                 return ClassFile.REF_invokeStatic;

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

   792                 return ClassFile.REF_invokeInterface;

   793             } else {

   794                 return ClassFile.REF_invokeVirtual;

   795             }

   796         }

   797     }

   798     // </editor-fold>

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

   801     /**

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

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

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

   805      */

   806     class LambdaAnalyzer extends TreeScanner {

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

   809         private List<Frame> frameStack;

   811         /**

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

   813          * names)

   814          */

   815         private int lambdaCount = 0;

   817         private void analyzeClass(JCClassDecl tree) {

   818             frameStack = List.nil();

   819             scan(tree);

   820         }

   822         @Override

   823         public void visitBlock(JCBlock tree) {

   824             List<Frame> prevStack = frameStack;

   825             try {

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

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

   828                 }

   829                 super.visitBlock(tree);

   830             }

   831             finally {

   832                 frameStack = prevStack;

   833             }

   834         }

   836         @Override

   837         public void visitClassDef(JCClassDecl tree) {

   838             List<Frame> prevStack = frameStack;

   839             try {

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

   841                     tree.sym.owner = owner();

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

   843                     Type encl = lambdaContext.enclosingType();

   844                     if (encl.hasTag(NONE)) {

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

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

   847                         tree.sym.flags_field |= STATIC;

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

   849                     } else {

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

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

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

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

   854                     }

   855                 }

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

   857                 super.visitClassDef(tree);

   858             }

   859             finally {

   860                 frameStack = prevStack;

   861             }

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

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

   864                 // because its constructor will reference the enclosing class

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

   866             }

   867         }

   869         @Override

   870         public void visitIdent(JCIdent tree) {

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

   872                 super.visitIdent(tree);

   873             } else {

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

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

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

   877                     TranslationContext<?> localContext = context();

   878                     while (localContext != null) {

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

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

   881                             if (block == null) break;

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

   883                         }

   884                         localContext = localContext.prev;

   885                     }

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

   887                     TranslationContext<?> localContext = context();

   888                     while (localContext != null) {

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

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

   891                             if (block == null) break;

   892                             switch (block.getTag()) {

   893                                 case CLASSDEF:

   894                                     JCClassDecl cdecl = (JCClassDecl)block;

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

   896                                     break;

   897                                 default:

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

   899                             }

   900                         }

   901                         localContext = localContext.prev;

   902                     }

   903                 }

   904             }

   905         }

   907         @Override

   908         public void visitLambda(JCLambda tree) {

   909             List<Frame> prevStack = frameStack;

   910             try {

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

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

   913                 for (JCVariableDecl param : tree.params) {

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

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

   916                 }

   917                 contextMap.put(tree, context);

   918                 scan(tree.body);

   919                 context.complete();

   920             }

   921             finally {

   922                 frameStack = prevStack;

   923             }

   924         }

   926         @Override

   927         public void visitMethodDef(JCMethodDecl tree) {

   928             List<Frame> prevStack = frameStack;

   929             try {

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

   931                 super.visitMethodDef(tree);

   932             }

   933             finally {

   934                 frameStack = prevStack;

   935             }

   936         }

   938         @Override

   939         public void visitNewClass(JCNewClass tree) {

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

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

   942             }

   943             super.visitNewClass(tree);

   944         }

   946         @Override

   947         public void visitReference(JCMemberReference tree) {

   948             scan(tree.getQualifierExpression());

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

   950         }

   952         @Override

   953         public void visitSelect(JCFieldAccess tree) {

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

   955                 TranslationContext<?> localContext = context();

   956                 while (localContext != null) {

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

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

   959                         if (clazz == null) break;

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

   961                     }

   962                     localContext = localContext.prev;

   963                 }

   964                 scan(tree.selected);

   965             } else {

   966                 super.visitSelect(tree);

   967             }

   968         }

   970         @Override

   971         public void visitVarDef(JCVariableDecl tree) {

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

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

   974             }

   975             List<Frame> prevStack = frameStack;

   976             try {

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

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

   979                 }

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

   981                 super.visitVarDef(tree);

   982             }

   983             finally {

   984                 frameStack = prevStack;

   985             }

   986         }

   988         private Name lambdaName() {

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

   990         }

   992         /**

   993          * Return a valid owner given the current declaration stack

   994          * (required to skip synthetic lambda symbols)

   995          */

   996         private Symbol owner() {

   997             List<Frame> frameStack2 = frameStack;

   998             while (frameStack2.nonEmpty()) {

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

  1000                     case VARDEF:

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

  1002                             frameStack2 = frameStack2.tail;

  1003                             break;

  1004                         }

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

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

  1007                     case BLOCK:

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

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

  1010                     case CLASSDEF:

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

  1012                     case METHODDEF:

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

  1014                     case LAMBDA:

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

  1016                     default:

  1017                         frameStack2 = frameStack2.tail;

  1018                 }

  1019             }

  1020             Assert.error();

  1021             return null;

  1022         }

  1024         private JCTree enclosingLambda() {

  1025             List<Frame> frameStack2 = frameStack;

  1026             while (frameStack2.nonEmpty()) {

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

  1028                     case CLASSDEF:

  1029                     case METHODDEF:

  1030                         return null;

  1031                     case LAMBDA:

  1032                         return frameStack2.head.tree;

  1033                     default:

  1034                         frameStack2 = frameStack2.tail;

  1035                 }

  1036             }

  1037             Assert.error();

  1038             return null;

  1039         }

  1041         /**

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

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

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

  1045          */

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

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

  1048             for (Frame block : frameStack) {

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

  1050                     case CLASSDEF:

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

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

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

  1054                         }

  1055                         break;

  1056                     case VARDEF:

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

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

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

  1060                         }

  1061                         break;

  1062                     case BLOCK:

  1063                     case METHODDEF:

  1064                     case LAMBDA:

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

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

  1067                         }

  1068                         break;

  1069                     default:

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

  1071                 }

  1072                 currentDepth--;

  1073             }

  1074             return null;

  1075         }

  1077         private TranslationContext<?> context() {

  1078             for (Frame frame : frameStack) {

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

  1080                 if (context != null) {

  1081                     return context;

  1082                 }

  1083             }

  1084             return null;

  1085         }

  1087         /**

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

  1089          *  when translating away lambda expressions

  1090          */

  1091         private boolean lambdaIdentSymbolFilter(Symbol sym) {

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

  1093                     && !sym.isStatic()

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

  1095         }

  1097         private boolean lambdaSelectSymbolFilter(Symbol sym) {

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

  1099                         !sym.isStatic() &&

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

  1101                         sym.name == names._super);

  1102         }

  1104         /**

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

  1106          * be qualified with an enclosing tree

  1107          */

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

  1109             if (context != null

  1110                     && tree.encl == null

  1111                     && tree.def == null

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

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

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

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

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

  1117                         return true;

  1118                     }

  1119                     current = current.getEnclosingType();

  1120                 }

  1121                 return false;

  1122             } else {

  1123                 return false;

  1124             }

  1125         }

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

  1128             return new LambdaTranslationContext(tree);

  1129         }

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

  1132             return new ReferenceTranslationContext(tree);

  1133         }

  1135         private class Frame {

  1136             final JCTree tree;

  1137             List<Symbol> locals;

  1139             public Frame(JCTree tree) {

  1140                 this.tree = tree;

  1141             }

  1143             void addLocal(Symbol sym) {

  1144                 if (locals == null) {

  1145                     locals = List.nil();

  1146                 }

  1147                 locals = locals.prepend(sym);

  1148             }

  1149         }

  1151         /**

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

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

  1154          */

  1155         private abstract class TranslationContext<T extends JCFunctionalExpression> {

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

  1158             T tree;

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

  1161             Symbol owner;

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

  1164             int depth;

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

  1167             TranslationContext<?> prev;

  1169             TranslationContext(T tree) {

  1170                 this.tree = tree;

  1171                 this.owner = owner();

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

  1173                 this.prev = context();

  1174             }

  1175         }

  1177         /**

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

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

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

  1181          * to captured locals/members, etc.

  1182          */

  1183         private class LambdaTranslationContext extends TranslationContext<JCLambda> {

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

  1186             Symbol self;

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

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

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

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

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

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

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

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

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

  1201             Symbol translatedSym;

  1203             List<JCVariableDecl> syntheticParams;

  1205             LambdaTranslationContext(JCLambda tree) {

  1206                 super(tree);

  1207                 Frame frame = frameStack.head;

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

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

  1210                 }

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

  1212             }

  1214             /**

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

  1216              * synthetic lambda body

  1217              */

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

  1219                 if (skind == CAPTURED_THIS) {

  1220                     return sym;  // self represented

  1221                 } else {

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

  1223                 }

  1224             }

  1226             void addSymbol(Symbol sym, LambdaSymbolKind skind) {

  1227                 Map<Symbol, Symbol> transMap = null;

  1228                 String preferredName;

  1229                 switch (skind) {

  1230                     case CAPTURED_THIS:

  1231                         transMap = capturedThis;

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

  1233                         break;

  1234                     case CAPTURED_VAR:

  1235                         transMap = capturedLocals;

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

  1237                         break;

  1238                     case LOCAL_VAR:

  1239                         transMap = lambdaLocals;

  1240                         preferredName = sym.name.toString();

  1241                         break;

  1242                     case PARAM:

  1243                         transMap = lambdaParams;

  1244                         preferredName = sym.name.toString();

  1245                         break;

  1246                     default: throw new AssertionError();

  1247                 }

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

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

  1250                 }

  1251             }

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

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

  1255                 for (LambdaSymbolKind skind : skinds) {

  1256                     switch (skind) {

  1257                         case CAPTURED_THIS:

  1258                             translationMap.putAll(capturedThis);

  1259                             break;

  1260                         case CAPTURED_VAR:

  1261                             translationMap.putAll(capturedLocals);

  1262                             break;

  1263                         case LOCAL_VAR:

  1264                             translationMap.putAll(lambdaLocals);

  1265                             break;

  1266                         case PARAM:

  1267                             translationMap.putAll(lambdaParams);

  1268                             break;

  1269                         default: throw new AssertionError();

  1270                     }

  1271                 }

  1272                 return translationMap;

  1273             }

  1275             /**

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

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

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

  1279              * and full parameter list.

  1280              */

  1281             void complete() {

  1282                 if (syntheticParams != null) {

  1283                     return;

  1284                 }

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

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

  1287                 boolean needInstance = thisReferenced || inInterface;

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

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

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

  1293                 //compute synthetic params

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

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

  1297                 // synthetic parameters:

  1298                 //

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

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

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

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

  1303                 }

  1305                 syntheticParams = params.toList();

  1307                 //prepend synthetic args to translated lambda method signature

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

  1309                         (MethodType) generatedLambdaSig(),

  1310                         TreeInfo.types(syntheticParams));

  1311             }

  1313             Type enclosingType() {

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

  1315                 return owner.enclClass().type;

  1316             }

  1318             Type generatedLambdaSig() {

  1319                 return types.erasure(tree.descriptorType);

  1320             }

  1321         }

  1323         /**

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

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

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

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

  1328          */

  1329         private class ReferenceTranslationContext extends TranslationContext<JCMemberReference> {

  1331             final boolean isSuper;

  1332             final Symbol bridgeSym;

  1334             ReferenceTranslationContext(JCMemberReference tree) {

  1335                 super(tree);

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

  1337                 this.bridgeSym = needsBridge()

  1338                         ? makeSyntheticMethod(isSuper ? 0 : STATIC,

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

  1340                                               owner.enclClass())

  1341                         : null;

  1342             }

  1344             /**

  1345              * Get the opcode associated with this method reference

  1346              */

  1347             int referenceKind() {

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

  1349             }

  1351             boolean needsVarArgsConversion() {

  1352                 return tree.varargsElement != null;

  1353             }

  1355             /**

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

  1357              */

  1358             boolean isArrayOp() {

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

  1360             }

  1362             /**

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

  1364              * expanded or "super" is used)

  1365              */

  1366             final boolean needsBridge() {

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

  1368             }

  1370             Type generatedRefSig() {

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

  1372             }

  1374             Type bridgedRefSig() {

  1375                 return types.erasure(types.findDescriptorSymbol(tree.targets.head).type);

  1376             }

  1377         }

  1378     }

  1379     // </editor-fold>

  1381     enum LambdaSymbolKind {

  1382         CAPTURED_VAR,

  1383         CAPTURED_THIS,

  1384         LOCAL_VAR,

  1385         PARAM;

  1386     }

  1387 }

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

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

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