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

     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                 init = null;

   306                 break;

   308             default:

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

   310         }

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

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

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

   317     }

   319     /**

   320      * Translate identifiers within a lambda to the mapped identifier

   321      * @param tree

   322      */

   323     @Override

   324     public void visitIdent(JCIdent tree) {

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

   326             super.visitIdent(tree);

   327         } else {

   328             LambdaTranslationContext lambdaContext = (LambdaTranslationContext) context;

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

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

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

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

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

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

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

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

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

   338             } else {

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

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

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

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

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

   344                                     ? enclRef.setType(tree.type)

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

   346                             result = tree;

   347                             return;

   348                         }

   349                     }

   350                 }

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

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

   353                 super.visitIdent(tree);

   354             }

   355         }

   356     }

   358     @Override

   359     public void visitVarDef(JCVariableDecl tree) {

   360         LambdaTranslationContext lambdaContext = (LambdaTranslationContext)context;

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

   362             JCExpression init = translate(tree.init);

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

   364         } else {

   365             super.visitVarDef(tree);

   366         }

   367     }

   369     // </editor-fold>

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

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

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

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

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

   377     }

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

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

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

   382         boolean isTarget_void = restype.hasTag(VOID);

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

   384         if (isTarget_void) {

   385             //target is void:

   386             // BODY;

   387             JCStatement stat = make.Exec(expr);

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

   389         } else if (isLambda_void && isTarget_Void) {

   390             //void to Void conversion:

   391             // BODY; return null;

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

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

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

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

   396         } else {

   397             //non-void to non-void conversion:

   398             // return (TYPE)BODY;

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

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

   401         }

   402     }

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

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

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

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

   409         class LambdaBodyTranslator extends TreeTranslator {

   411             @Override

   412             public void visitClassDef(JCClassDecl tree) {

   413                 //do NOT recurse on any inner classes

   414                 result = tree;

   415             }

   417             @Override

   418             public void visitLambda(JCLambda tree) {

   419                 //do NOT recurse on any nested lambdas

   420                 result = tree;

   421             }

   423             @Override

   424             public void visitReturn(JCReturn tree) {

   425                 boolean isLambda_void = tree.expr == null;

   426                 if (isTarget_void && !isLambda_void) {

   427                     //Void to void conversion:

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

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

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

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

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

   433                     //non-void to non-void conversion:

   434                     // return (TYPE)RET-EXPR;

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

   436                     result = tree;

   437                 } else {

   438                     result = tree;

   439                 }

   441             }

   442         }

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

   445         if (completeNormally && isTarget_Void) {

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

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

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

   449         }

   450         return trans_block;

   451     }

   453     /**

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

   455      */

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

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

   458     }

   460     /**

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

   462      */

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

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

   465     }

   467     /**

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

   469      */

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

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

   472     }

   474     /**

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

   476      * or a method call tree)

   477      */

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

   479         if (varargsElement != null) {

   480             switch (tree.getTag()) {

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

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

   483                 default: throw new AssertionError();

   484             }

   485         }

   486     }

   488     /**

   489      * Convert method/constructor arguments by inserting appropriate cast

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

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

   492      * with the generated signature.

   493      */

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

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

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

   497        if (varargsElement != null) {

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

   499        }

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

   501     }

   503     // </editor-fold>

   505     private MethodSymbol makeSamDescriptor(Type targetType) {

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

   507     }

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

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

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

   512     }

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

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

   516     }

   518     /**

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

   520      * be used directly.

   521      */

   522     private class MemberReferenceBridger {

   524         private final JCMemberReference tree;

   525         private final ReferenceTranslationContext localContext;

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

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

   529         MemberReferenceBridger(JCMemberReference tree, ReferenceTranslationContext localContext) {

   530             this.tree = tree;

   531             this.localContext = localContext;

   532         }

   534         /**

   535          * Generate the bridge

   536          */

   537         JCMethodDecl bridge() {

   538             int prevPos = make.pos;

   539             try {

   540                 make.at(tree);

   541                 Type samDesc = localContext.bridgedRefSig();

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

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

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

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

   547                 Type recType = null;

   548                 switch (tree.kind) {

   549                     case IMPLICIT_INNER:

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

   551                         break;

   552                     case BOUND:

   553                         recType = tree.getQualifierExpression().type;

   554                         break;

   555                     case UNBOUND:

   556                         recType = samPTypes.head;

   557                         samPTypes = samPTypes.tail;

   558                         break;

   559                 }

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

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

   564                 VarSymbol rcvr = (recType == null)

   565                         ? null

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

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

   569                 int refSize = refPTypes.size();

   570                 int samSize = samPTypes.size();

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

   573                 List<Type> l = refPTypes;

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

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

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

   577                     l = l.tail;

   578                 }

   579                 // Flatten out the var args

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

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

   582                 }

   584                 //generate the bridge method declaration

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

   586                         localContext.bridgeSym.name,

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

   588                         List.<JCTypeParameter>nil(),

   589                         params.toList(),

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

   591                         ? List.<JCExpression>nil()

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

   593                         null,

   594                         null);

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

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

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

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

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

   601                         ? bridgeExpressionInvoke(rcvr)

   602                         : bridgeExpressionNew();

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

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

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

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

   609                 return bridgeDecl;

   610             } finally {

   611                 make.at(prevPos);

   612             }

   613         }

   615         /**

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

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

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

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

   620          */

   621         private JCExpression bridgeExpressionInvoke(VarSymbol rcvr) {

   622             JCExpression qualifier =

   623                     tree.sym.isStatic() ?

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

   625                         (rcvr != null) ?

   626                             make.Ident(rcvr) :

   627                             tree.getQualifierExpression();

   629             //create the qualifier expression

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

   631             select.sym = tree.sym;

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

   634             //create the method call expression

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

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

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

   639             setVarargsIfNeeded(apply, tree.varargsElement);

   640             return apply;

   641         }

   643         /**

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

   645          * to the first bridge synthetic parameter

   646          */

   647         private JCExpression bridgeExpressionNew() {

   648             JCExpression encl = null;

   649             switch (tree.kind) {

   650                 case UNBOUND:

   651                 case IMPLICIT_INNER:

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

   653             }

   655             //create the instance creation expression

   656             JCNewClass newClass = make.NewClass(encl,

   657                     List.<JCExpression>nil(),

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

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

   660                     null);

   661             newClass.constructor = tree.sym;

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

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

   664             setVarargsIfNeeded(newClass, tree.varargsElement);

   665             return newClass;

   666         }

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

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

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

   671             if (genArg) {

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

   673             }

   674             return vsym;

   675         }

   676     }

   678     /**

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

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

   681      * * super is used

   682      */

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

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

   685         translatedMethodList = translatedMethodList.prepend(bridgeDecl);

   686     }

   688     /**

   689      * Generate an indy method call to the meta factory

   690      */

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

   692         //determine the static bsm args

   693         Type mtype = makeFunctionalDescriptorType(targetType, true);

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

   695                 new Pool.MethodHandle(ClassFile.REF_invokeInterface,

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

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

   698                 new MethodType(mtype.getParameterTypes(),

   699                         mtype.getReturnType(),

   700                         mtype.getThrownTypes(),

   701                         syms.methodClass));

   703         //computed indy arg types

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

   705         for (JCExpression arg : indy_args) {

   706             indy_args_types.append(arg.type);

   707         }

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

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

   711                 tree.type,

   712                 List.<Type>nil(),

   713                 syms.methodClass);

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

   716     }

   718     /**

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

   720      * arguments types

   721      */

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

   723         int prevPos = make.pos;

   724         try {

   725             make.at(pos);

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

   727                     syms.stringType,

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

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

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

   733             DynamicMethodSymbol dynSym =

   734                     new DynamicMethodSymbol(names.lambda,

   735                                             syms.noSymbol,

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

   737                                             (MethodSymbol)bsm,

   738                                             indyType,

   739                                             staticArgs.toArray());

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

   742             qualifier.sym = dynSym;

   743             qualifier.type = indyType.getReturnType();

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

   746             proxyCall.type = indyType.getReturnType();

   747             return proxyCall;

   748         } finally {

   749             make.at(prevPos);

   750         }

   751     }

   752     //where

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

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

   755         for (Object arg : args) {

   756             argtypes.append(bsmStaticArgToType(arg));

   757         }

   758         return argtypes.toList();

   759     }

   761     private Type bsmStaticArgToType(Object arg) {

   762         Assert.checkNonNull(arg);

   763         if (arg instanceof ClassSymbol) {

   764             return syms.classType;

   765         } else if (arg instanceof Integer) {

   766             return syms.intType;

   767         } else if (arg instanceof Long) {

   768             return syms.longType;

   769         } else if (arg instanceof Float) {

   770             return syms.floatType;

   771         } else if (arg instanceof Double) {

   772             return syms.doubleType;

   773         } else if (arg instanceof String) {

   774             return syms.stringType;

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

   776             return syms.methodHandleType;

   777         } else if (arg instanceof MethodType) {

   778             return syms.methodTypeType;

   779         } else {

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

   781             return null;

   782         }

   783     }

   785     /**

   786      * Get the opcode associated with this method reference

   787      */

   788     private int referenceKind(Symbol refSym) {

   789         if (refSym.isConstructor()) {

   790             return ClassFile.REF_newInvokeSpecial;

   791         } else {

   792             if (refSym.isStatic()) {

   793                 return ClassFile.REF_invokeStatic;

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

   795                 return ClassFile.REF_invokeInterface;

   796             } else {

   797                 return ClassFile.REF_invokeVirtual;

   798             }

   799         }

   800     }

   801     // </editor-fold>

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

   804     /**

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

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

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

   808      */

   809     class LambdaAnalyzer extends TreeScanner {

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

   812         private List<Frame> frameStack;

   814         /**

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

   816          * names)

   817          */

   818         private int lambdaCount = 0;

   820         private void analyzeClass(JCClassDecl tree) {

   821             frameStack = List.nil();

   822             scan(tree);

   823         }

   825         @Override

   826         public void visitBlock(JCBlock tree) {

   827             List<Frame> prevStack = frameStack;

   828             try {

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

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

   831                 }

   832                 super.visitBlock(tree);

   833             }

   834             finally {

   835                 frameStack = prevStack;

   836             }

   837         }

   839         @Override

   840         public void visitClassDef(JCClassDecl tree) {

   841             List<Frame> prevStack = frameStack;

   842             try {

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

   844                     tree.sym.owner = owner();

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

   846                     Type encl = lambdaContext.enclosingType();

   847                     if (encl.hasTag(NONE)) {

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

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

   850                         tree.sym.flags_field |= STATIC;

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

   852                     } else {

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

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

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

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

   857                     }

   858                 }

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

   860                 super.visitClassDef(tree);

   861             }

   862             finally {

   863                 frameStack = prevStack;

   864             }

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

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

   867                 // because its constructor will reference the enclosing class

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

   869             }

   870         }

   872         @Override

   873         public void visitIdent(JCIdent tree) {

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

   875                 super.visitIdent(tree);

   876             } else {

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

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

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

   880                     TranslationContext<?> localContext = context();

   881                     while (localContext != null) {

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

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

   884                             if (block == null) break;

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

   886                         }

   887                         localContext = localContext.prev;

   888                     }

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

   890                     TranslationContext<?> localContext = context();

   891                     while (localContext != null) {

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

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

   894                             if (block == null) break;

   895                             switch (block.getTag()) {

   896                                 case CLASSDEF:

   897                                     JCClassDecl cdecl = (JCClassDecl)block;

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

   899                                     break;

   900                                 default:

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

   902                             }

   903                         }

   904                         localContext = localContext.prev;

   905                     }

   906                 }

   907             }

   908         }

   910         @Override

   911         public void visitLambda(JCLambda tree) {

   912             List<Frame> prevStack = frameStack;

   913             try {

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

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

   916                 for (JCVariableDecl param : tree.params) {

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

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

   919                 }

   920                 contextMap.put(tree, context);

   921                 scan(tree.body);

   922                 context.complete();

   923             }

   924             finally {

   925                 frameStack = prevStack;

   926             }

   927         }

   929         @Override

   930         public void visitMethodDef(JCMethodDecl tree) {

   931             List<Frame> prevStack = frameStack;

   932             try {

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

   934                 super.visitMethodDef(tree);

   935             }

   936             finally {

   937                 frameStack = prevStack;

   938             }

   939         }

   941         @Override

   942         public void visitNewClass(JCNewClass tree) {

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

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

   945             }

   946             super.visitNewClass(tree);

   947         }

   949         @Override

   950         public void visitReference(JCMemberReference tree) {

   951             scan(tree.getQualifierExpression());

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

   953         }

   955         @Override

   956         public void visitSelect(JCFieldAccess tree) {

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

   958                 TranslationContext<?> localContext = context();

   959                 while (localContext != null) {

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

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

   962                         if (clazz == null) break;

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

   964                     }

   965                     localContext = localContext.prev;

   966                 }

   967                 scan(tree.selected);

   968             } else {

   969                 super.visitSelect(tree);

   970             }

   971         }

   973         @Override

   974         public void visitVarDef(JCVariableDecl tree) {

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

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

   977             }

   978             List<Frame> prevStack = frameStack;

   979             try {

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

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

   982                 }

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

   984                 super.visitVarDef(tree);

   985             }

   986             finally {

   987                 frameStack = prevStack;

   988             }

   989         }

   991         private Name lambdaName() {

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

   993         }

   995         /**

   996          * Return a valid owner given the current declaration stack

   997          * (required to skip synthetic lambda symbols)

   998          */

   999         private Symbol owner() {

  1000             List<Frame> frameStack2 = frameStack;

  1001             while (frameStack2.nonEmpty()) {

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

  1003                     case VARDEF:

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

  1005                             frameStack2 = frameStack2.tail;

  1006                             break;

  1007                         }

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

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

  1010                     case BLOCK:

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

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

  1013                     case CLASSDEF:

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

  1015                     case METHODDEF:

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

  1017                     case LAMBDA:

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

  1019                     default:

  1020                         frameStack2 = frameStack2.tail;

  1021                 }

  1022             }

  1023             Assert.error();

  1024             return null;

  1025         }

  1027         private JCTree enclosingLambda() {

  1028             List<Frame> frameStack2 = frameStack;

  1029             while (frameStack2.nonEmpty()) {

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

  1031                     case CLASSDEF:

  1032                     case METHODDEF:

  1033                         return null;

  1034                     case LAMBDA:

  1035                         return frameStack2.head.tree;

  1036                     default:

  1037                         frameStack2 = frameStack2.tail;

  1038                 }

  1039             }

  1040             Assert.error();

  1041             return null;

  1042         }

  1044         /**

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

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

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

  1048          */

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

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

  1051             for (Frame block : frameStack) {

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

  1053                     case CLASSDEF:

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

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

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

  1057                         }

  1058                         break;

  1059                     case VARDEF:

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

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

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

  1063                         }

  1064                         break;

  1065                     case BLOCK:

  1066                     case METHODDEF:

  1067                     case LAMBDA:

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

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

  1070                         }

  1071                         break;

  1072                     default:

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

  1074                 }

  1075                 currentDepth--;

  1076             }

  1077             return null;

  1078         }

  1080         private TranslationContext<?> context() {

  1081             for (Frame frame : frameStack) {

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

  1083                 if (context != null) {

  1084                     return context;

  1085                 }

  1086             }

  1087             return null;

  1088         }

  1090         /**

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

  1092          *  when translating away lambda expressions

  1093          */

  1094         private boolean lambdaIdentSymbolFilter(Symbol sym) {

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

  1096                     && !sym.isStatic()

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

  1098         }

  1100         private boolean lambdaSelectSymbolFilter(Symbol sym) {

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

  1102                         !sym.isStatic() &&

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

  1104                         sym.name == names._super);

  1105         }

  1107         /**

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

  1109          * be qualified with an enclosing tree

  1110          */

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

  1112             if (context != null

  1113                     && tree.encl == null

  1114                     && tree.def == null

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

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

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

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

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

  1120                         return true;

  1121                     }

  1122                     current = current.getEnclosingType();

  1123                 }

  1124                 return false;

  1125             } else {

  1126                 return false;

  1127             }

  1128         }

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

  1131             return new LambdaTranslationContext(tree);

  1132         }

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

  1135             return new ReferenceTranslationContext(tree);

  1136         }

  1138         private class Frame {

  1139             final JCTree tree;

  1140             List<Symbol> locals;

  1142             public Frame(JCTree tree) {

  1143                 this.tree = tree;

  1144             }

  1146             void addLocal(Symbol sym) {

  1147                 if (locals == null) {

  1148                     locals = List.nil();

  1149                 }

  1150                 locals = locals.prepend(sym);

  1151             }

  1152         }

  1154         /**

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

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

  1157          */

  1158         private abstract class TranslationContext<T extends JCTree> {

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

  1161             T tree;

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

  1164             Symbol owner;

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

  1167             int depth;

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

  1170             TranslationContext<?> prev;

  1172             TranslationContext(T tree) {

  1173                 this.tree = tree;

  1174                 this.owner = owner();

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

  1176                 this.prev = context();

  1177             }

  1178         }

  1180         /**

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

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

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

  1184          * to captured locals/members, etc.

  1185          */

  1186         private class LambdaTranslationContext extends TranslationContext<JCLambda> {

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

  1189             Symbol self;

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

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

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

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

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

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

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

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

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

  1204             Symbol translatedSym;

  1206             List<JCVariableDecl> syntheticParams;

  1208             LambdaTranslationContext(JCLambda tree) {

  1209                 super(tree);

  1210                 Frame frame = frameStack.head;

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

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

  1213                 }

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

  1215             }

  1217             /**

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

  1219              * synthetic lambda body

  1220              */

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

  1222                 if (skind == CAPTURED_THIS) {

  1223                     return sym;  // self represented

  1224                 } else {

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

  1226                 }

  1227             }

  1229             void addSymbol(Symbol sym, LambdaSymbolKind skind) {

  1230                 Map<Symbol, Symbol> transMap = null;

  1231                 String preferredName;

  1232                 switch (skind) {

  1233                     case CAPTURED_THIS:

  1234                         transMap = capturedThis;

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

  1236                         break;

  1237                     case CAPTURED_VAR:

  1238                         transMap = capturedLocals;

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

  1240                         break;

  1241                     case LOCAL_VAR:

  1242                         transMap = lambdaLocals;

  1243                         preferredName = sym.name.toString();

  1244                         break;

  1245                     case PARAM:

  1246                         transMap = lambdaParams;

  1247                         preferredName = sym.name.toString();

  1248                         break;

  1249                     default: throw new AssertionError();

  1250                 }

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

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

  1253                 }

  1254             }

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

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

  1258                 for (LambdaSymbolKind skind : skinds) {

  1259                     switch (skind) {

  1260                         case CAPTURED_THIS:

  1261                             translationMap.putAll(capturedThis);

  1262                             break;

  1263                         case CAPTURED_VAR:

  1264                             translationMap.putAll(capturedLocals);

  1265                             break;

  1266                         case LOCAL_VAR:

  1267                             translationMap.putAll(lambdaLocals);

  1268                             break;

  1269                         case PARAM:

  1270                             translationMap.putAll(lambdaParams);

  1271                             break;

  1272                         default: throw new AssertionError();

  1273                     }

  1274                 }

  1275                 return translationMap;

  1276             }

  1278             /**

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

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

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

  1282              * and full parameter list.

  1283              */

  1284             void complete() {

  1285                 if (syntheticParams != null) {

  1286                     return;

  1287                 }

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

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

  1290                 boolean needInstance = thisReferenced || inInterface;

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

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

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

  1296                 //compute synthetic params

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

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

  1300                 // synthetic parameters:

  1301                 //

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

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

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

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

  1306                 }

  1308                 syntheticParams = params.toList();

  1310                 //prepend synthetic args to translated lambda method signature

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

  1312                         (MethodType) generatedLambdaSig(),

  1313                         TreeInfo.types(syntheticParams));

  1314             }

  1316             Type enclosingType() {

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

  1318                 return owner.enclClass().type;

  1319             }

  1321             Type generatedLambdaSig() {

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

  1323             }

  1324         }

  1326         /**

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

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

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

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

  1331          */

  1332         private class ReferenceTranslationContext extends TranslationContext<JCMemberReference> {

  1334             final boolean isSuper;

  1335             final Symbol bridgeSym;

  1337             ReferenceTranslationContext(JCMemberReference tree) {

  1338                 super(tree);

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

  1340                 this.bridgeSym = needsBridge()

  1341                         ? makeSyntheticMethod(isSuper ? 0 : STATIC,

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

  1343                                               owner.enclClass())

  1344                         : null;

  1345             }

  1347             /**

  1348              * Get the opcode associated with this method reference

  1349              */

  1350             int referenceKind() {

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

  1352             }

  1354             boolean needsVarArgsConversion() {

  1355                 return tree.varargsElement != null;

  1356             }

  1358             /**

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

  1360              */

  1361             boolean isArrayOp() {

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

  1363             }

  1365             /**

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

  1367              * expanded or "super" is used)

  1368              */

  1369             final boolean needsBridge() {

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

  1371             }

  1373             Type generatedRefSig() {

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

  1375             }

  1377             Type bridgedRefSig() {

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

  1379             }

  1380         }

  1381     }

  1382     // </editor-fold>

  1384     enum LambdaSymbolKind {

  1385         CAPTURED_VAR,

  1386         CAPTURED_THIS,

  1387         LOCAL_VAR,

  1388         PARAM;

  1389     }

  1390 }

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

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

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