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

8004101: Add checks for method reference well-formedness
Summary: Bring method reference type-checking in sync with latest EDR
Reviewed-by: jjg

     1 /*

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

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

     4  *

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

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

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

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

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

    10  *

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

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

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

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

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

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

    23  * questions.

    24  */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    53 import java.util.HashMap;

    54 import java.util.LinkedHashMap;

    55 import java.util.Map;

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

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

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

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

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

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

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

    65 /**

    66  * This pass desugars lambda expressions into static methods

    67  *

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

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

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

    71  *  deletion without notice.</b>

    72  */

    73 public class LambdaToMethod extends TreeTranslator {

    75     private Names names;

    76     private Symtab syms;

    77     private Resolve rs;

    78     private TreeMaker make;

    79     private Types types;

    80     private TransTypes transTypes;

    81     private Env<AttrContext> attrEnv;

    83     /** the analyzer scanner */

    84     private LambdaAnalyzer analyzer;

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

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

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

    90     private TranslationContext<?> context;

    92     /** list of translated methods

    93      **/

    94     private ListBuffer<JCTree> translatedMethodList;

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

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

    98             new Context.Key<LambdaToMethod>();

   100     public static LambdaToMethod instance(Context context) {

   101         LambdaToMethod instance = context.get(unlambdaKey);

   102         if (instance == null) {

   103             instance = new LambdaToMethod(context);

   104         }

   105         return instance;

   106     }

   108     private LambdaToMethod(Context context) {

   109         names = Names.instance(context);

   110         syms = Symtab.instance(context);

   111         rs = Resolve.instance(context);

   112         make = TreeMaker.instance(context);

   113         types = Types.instance(context);

   114         transTypes = TransTypes.instance(context);

   115         this.analyzer = makeAnalyzer();

   116     }

   118     private LambdaAnalyzer makeAnalyzer() {

   119         return new LambdaAnalyzer();

   120     }

   121     // </editor-fold>

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

   124     @Override

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

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

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

   128     }

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

   131         TranslationContext<?> prevContext = context;

   132         try {

   133             context = newContext;

   134             return super.translate(tree);

   135         }

   136         finally {

   137             context = prevContext;

   138         }

   139     }

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

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

   143         for (T tree : trees) {

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

   145         }

   146         return buf.toList();

   147     }

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

   150         this.make = make;

   151         this.attrEnv = env;

   152         this.context = null;

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

   154         return translate(cdef);

   155     }

   156     // </editor-fold>

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

   159     /**

   160      * Visit a class.

   161      * Maintain the translatedMethodList across nested classes.

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

   163      * @param tree

   164      */

   165     @Override

   166     public void visitClassDef(JCClassDecl tree) {

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

   168             //analyze class

   169             analyzer.analyzeClass(tree);

   170         }

   171         ListBuffer<JCTree> prevTranslated = translatedMethodList;

   172         try {

   173             translatedMethodList = ListBuffer.lb();

   174             super.visitClassDef(tree);

   175             //add all translated instance methods here

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

   177             for (JCTree lambda : translatedMethodList) {

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

   179             }

   180             result = tree;

   181         } finally {

   182             translatedMethodList = prevTranslated;

   183         }

   184     }

   186     /**

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

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

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

   190      * @param tree

   191      */

   192     @Override

   193     public void visitLambda(JCLambda tree) {

   194         LambdaTranslationContext localContext = (LambdaTranslationContext)context;

   195         MethodSymbol sym = (MethodSymbol)localContext.translatedSym;

   196         MethodType lambdaType = (MethodType) sym.type;

   198         //create the method declaration hoisting the lambda body

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

   200                 sym.name,

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

   202                 List.<JCTypeParameter>nil(),

   203                 localContext.syntheticParams,

   204                 lambdaType.getThrownTypes() == null ?

   205                     List.<JCExpression>nil() :

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

   207                 null,

   208                 null);

   209         lambdaDecl.sym = sym;

   210         lambdaDecl.type = lambdaType;

   212         //translate lambda body

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

   214         //captured variables, enclosing members are adjusted accordingly

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

   216         //captured members directly).

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

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

   220         translatedMethodList = translatedMethodList.prepend(lambdaDecl);

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

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

   224         //created method.

   225         //

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

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

   228         //should be added the following synthetic arguments:

   229         //

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

   231         // * enclosing locals captured by the lambda expression

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

   235         if (!sym.isStatic()) {

   236             syntheticInits.append(makeThis(

   237                     sym.owner.asType(),

   238                     localContext.owner.enclClass()));

   239         }

   241         //add captured locals

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

   243             if (fv != localContext.self) {

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

   245                 syntheticInits.append((JCExpression) captured_local);

   246             }

   247         }

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

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

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

   253         int refKind = referenceKind(sym);

   255         //convert to an invokedynamic call

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

   257     }

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

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

   261                 names._this,

   262                 type,

   263                 owner);

   264         return make.Ident(_this);

   265     }

   267     /**

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

   269      * meta-factory.

   270      * @param tree

   271      */

   272     @Override

   273     public void visitReference(JCMemberReference tree) {

   274         ReferenceTranslationContext localContext = (ReferenceTranslationContext)context;

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

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

   278         Symbol refSym = localContext.needsBridge() ?

   279             localContext.bridgeSym :

   280             tree.sym;

   282         //build the bridge method, if needed

   283         if (localContext.needsBridge()) {

   284             bridgeMemberReference(tree, localContext);

   285         }

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

   288         JCExpression init;

   289         switch(tree.kind) {

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

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

   293                 init = makeThis(

   294                     localContext.owner.owner.asType(),

   295                     localContext.owner);

   296                 break;

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

   299                 init = tree.getQualifierExpression();

   300                 break;

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

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

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

   305                 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, types.findDescriptorSymbol(targetType.tsym)),

   696                 new Pool.MethodHandle(refKind, refSym),

   697                 new MethodType(mtype.getParameterTypes(),

   698                         mtype.getReturnType(),

   699                         mtype.getThrownTypes(),

   700                         syms.methodClass));

   702         //computed indy arg types

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

   704         for (JCExpression arg : indy_args) {

   705             indy_args_types.append(arg.type);

   706         }

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

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

   710                 tree.type,

   711                 List.<Type>nil(),

   712                 syms.methodClass);

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

   715     }

   717     /**

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

   719      * arguments types

   720      */

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

   722         int prevPos = make.pos;

   723         try {

   724             make.at(pos);

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

   726                     syms.stringType,

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

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

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

   732             DynamicMethodSymbol dynSym =

   733                     new DynamicMethodSymbol(names.lambda,

   734                                             syms.noSymbol,

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

   736                                             (MethodSymbol)bsm,

   737                                             indyType,

   738                                             staticArgs.toArray());

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

   741             qualifier.sym = dynSym;

   742             qualifier.type = indyType.getReturnType();

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

   745             proxyCall.type = indyType.getReturnType();

   746             return proxyCall;

   747         } finally {

   748             make.at(prevPos);

   749         }

   750     }

   751     //where

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

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

   754         for (Object arg : args) {

   755             argtypes.append(bsmStaticArgToType(arg));

   756         }

   757         return argtypes.toList();

   758     }

   760     private Type bsmStaticArgToType(Object arg) {

   761         Assert.checkNonNull(arg);

   762         if (arg instanceof ClassSymbol) {

   763             return syms.classType;

   764         } else if (arg instanceof Integer) {

   765             return syms.intType;

   766         } else if (arg instanceof Long) {

   767             return syms.longType;

   768         } else if (arg instanceof Float) {

   769             return syms.floatType;

   770         } else if (arg instanceof Double) {

   771             return syms.doubleType;

   772         } else if (arg instanceof String) {

   773             return syms.stringType;

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

   775             return syms.methodHandleType;

   776         } else if (arg instanceof MethodType) {

   777             return syms.methodTypeType;

   778         } else {

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

   780             return null;

   781         }

   782     }

   784     /**

   785      * Get the opcode associated with this method reference

   786      */

   787     private int referenceKind(Symbol refSym) {

   788         if (refSym.isConstructor()) {

   789             return ClassFile.REF_newInvokeSpecial;

   790         } else {

   791             if (refSym.isStatic()) {

   792                 return ClassFile.REF_invokeStatic;

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

   794                 return ClassFile.REF_invokeInterface;

   795             } else {

   796                 return ClassFile.REF_invokeVirtual;

   797             }

   798         }

   799     }

   800     // </editor-fold>

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

   803     /**

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

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

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

   807      */

   808     class LambdaAnalyzer extends TreeScanner {

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

   811         private List<Frame> frameStack;

   813         /**

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

   815          * names)

   816          */

   817         private int lambdaCount = 0;

   819         private void analyzeClass(JCClassDecl tree) {

   820             frameStack = List.nil();

   821             scan(tree);

   822         }

   824         @Override

   825         public void visitBlock(JCBlock tree) {

   826             List<Frame> prevStack = frameStack;

   827             try {

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

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

   830                 }

   831                 super.visitBlock(tree);

   832             }

   833             finally {

   834                 frameStack = prevStack;

   835             }

   836         }

   838         @Override

   839         public void visitClassDef(JCClassDecl tree) {

   840             List<Frame> prevStack = frameStack;

   841             try {

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

   843                     tree.sym.owner = owner();

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

   845                     Type encl = lambdaContext.enclosingType();

   846                     if (encl.hasTag(NONE)) {

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

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

   849                         tree.sym.flags_field |= STATIC;

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

   851                     } else {

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

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

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

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

   856                     }

   857                 }

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

   859                 super.visitClassDef(tree);

   860             }

   861             finally {

   862                 frameStack = prevStack;

   863             }

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

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

   866                 // because its constructor will reference the enclosing class

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

   868             }

   869         }

   871         @Override

   872         public void visitIdent(JCIdent tree) {

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

   874                 super.visitIdent(tree);

   875             } else {

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

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

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

   879                     TranslationContext<?> localContext = context();

   880                     while (localContext != null) {

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

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

   883                             if (block == null) break;

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

   885                         }

   886                         localContext = localContext.prev;

   887                     }

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

   889                     TranslationContext<?> localContext = context();

   890                     while (localContext != null) {

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

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

   893                             if (block == null) break;

   894                             switch (block.getTag()) {

   895                                 case CLASSDEF:

   896                                     JCClassDecl cdecl = (JCClassDecl)block;

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

   898                                     break;

   899                                 default:

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

   901                             }

   902                         }

   903                         localContext = localContext.prev;

   904                     }

   905                 }

   906             }

   907         }

   909         @Override

   910         public void visitLambda(JCLambda tree) {

   911             List<Frame> prevStack = frameStack;

   912             try {

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

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

   915                 for (JCVariableDecl param : tree.params) {

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

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

   918                 }

   919                 contextMap.put(tree, context);

   920                 scan(tree.body);

   921                 context.complete();

   922             }

   923             finally {

   924                 frameStack = prevStack;

   925             }

   926         }

   928         @Override

   929         public void visitMethodDef(JCMethodDecl tree) {

   930             List<Frame> prevStack = frameStack;

   931             try {

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

   933                 super.visitMethodDef(tree);

   934             }

   935             finally {

   936                 frameStack = prevStack;

   937             }

   938         }

   940         @Override

   941         public void visitNewClass(JCNewClass tree) {

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

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

   944             }

   945             super.visitNewClass(tree);

   946         }

   948         @Override

   949         public void visitReference(JCMemberReference tree) {

   950             scan(tree.getQualifierExpression());

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

   952         }

   954         @Override

   955         public void visitSelect(JCFieldAccess tree) {

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

   957                 TranslationContext<?> localContext = context();

   958                 while (localContext != null) {

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

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

   961                         if (clazz == null) break;

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

   963                     }

   964                     localContext = localContext.prev;

   965                 }

   966                 scan(tree.selected);

   967             } else {

   968                 super.visitSelect(tree);

   969             }

   970         }

   972         @Override

   973         public void visitVarDef(JCVariableDecl tree) {

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

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

   976             }

   977             List<Frame> prevStack = frameStack;

   978             try {

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

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

   981                 }

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

   983                 super.visitVarDef(tree);

   984             }

   985             finally {

   986                 frameStack = prevStack;

   987             }

   988         }

   990         private Name lambdaName() {

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

   992         }

   994         /**

   995          * Return a valid owner given the current declaration stack

   996          * (required to skip synthetic lambda symbols)

   997          */

   998         private Symbol owner() {

   999             List<Frame> frameStack2 = frameStack;

  1000             while (frameStack2.nonEmpty()) {

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

  1002                     case VARDEF:

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

  1004                             frameStack2 = frameStack2.tail;

  1005                             break;

  1006                         }

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

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

  1009                     case BLOCK:

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

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

  1012                     case CLASSDEF:

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

  1014                     case METHODDEF:

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

  1016                     case LAMBDA:

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

  1018                     default:

  1019                         frameStack2 = frameStack2.tail;

  1020                 }

  1021             }

  1022             Assert.error();

  1023             return null;

  1024         }

  1026         private JCTree enclosingLambda() {

  1027             List<Frame> frameStack2 = frameStack;

  1028             while (frameStack2.nonEmpty()) {

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

  1030                     case CLASSDEF:

  1031                     case METHODDEF:

  1032                         return null;

  1033                     case LAMBDA:

  1034                         return frameStack2.head.tree;

  1035                     default:

  1036                         frameStack2 = frameStack2.tail;

  1037                 }

  1038             }

  1039             Assert.error();

  1040             return null;

  1041         }

  1043         /**

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

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

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

  1047          */

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

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

  1050             for (Frame block : frameStack) {

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

  1052                     case CLASSDEF:

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

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

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

  1056                         }

  1057                         break;

  1058                     case VARDEF:

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

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

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

  1062                         }

  1063                         break;

  1064                     case BLOCK:

  1065                     case METHODDEF:

  1066                     case LAMBDA:

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

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

  1069                         }

  1070                         break;

  1071                     default:

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

  1073                 }

  1074                 currentDepth--;

  1075             }

  1076             return null;

  1077         }

  1079         private TranslationContext<?> context() {

  1080             for (Frame frame : frameStack) {

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

  1082                 if (context != null) {

  1083                     return context;

  1084                 }

  1085             }

  1086             return null;

  1087         }

  1089         /**

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

  1091          *  when translating away lambda expressions

  1092          */

  1093         private boolean lambdaIdentSymbolFilter(Symbol sym) {

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

  1095                     && !sym.isStatic()

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

  1097         }

  1099         private boolean lambdaSelectSymbolFilter(Symbol sym) {

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

  1101                         !sym.isStatic() &&

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

  1103                         sym.name == names._super);

  1104         }

  1106         /**

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

  1108          * be qualified with an enclosing tree

  1109          */

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

  1111             if (context != null

  1112                     && tree.encl == null

  1113                     && tree.def == null

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

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

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

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

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

  1119                         return true;

  1120                     }

  1121                     current = current.getEnclosingType();

  1122                 }

  1123                 return false;

  1124             } else {

  1125                 return false;

  1126             }

  1127         }

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

  1130             return new LambdaTranslationContext(tree);

  1131         }

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

  1134             return new ReferenceTranslationContext(tree);

  1135         }

  1137         private class Frame {

  1138             final JCTree tree;

  1139             List<Symbol> locals;

  1141             public Frame(JCTree tree) {

  1142                 this.tree = tree;

  1143             }

  1145             void addLocal(Symbol sym) {

  1146                 if (locals == null) {

  1147                     locals = List.nil();

  1148                 }

  1149                 locals = locals.prepend(sym);

  1150             }

  1151         }

  1153         /**

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

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

  1156          */

  1157         private abstract class TranslationContext<T extends JCTree> {

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

  1160             T tree;

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

  1163             Symbol owner;

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

  1166             int depth;

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

  1169             TranslationContext<?> prev;

  1171             TranslationContext(T tree) {

  1172                 this.tree = tree;

  1173                 this.owner = owner();

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

  1175                 this.prev = context();

  1176             }

  1177         }

  1179         /**

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

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

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

  1183          * to captured locals/members, etc.

  1184          */

  1185         private class LambdaTranslationContext extends TranslationContext<JCLambda> {

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

  1188             Symbol self;

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

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

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

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

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

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

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

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

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

  1203             Symbol translatedSym;

  1205             List<JCVariableDecl> syntheticParams;

  1207             LambdaTranslationContext(JCLambda tree) {

  1208                 super(tree);

  1209                 Frame frame = frameStack.head;

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

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

  1212                 }

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

  1214             }

  1216             /**

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

  1218              * synthetic lambda body

  1219              */

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

  1221                 if (skind == CAPTURED_THIS) {

  1222                     return sym;  // self represented

  1223                 } else {

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

  1225                 }

  1226             }

  1228             void addSymbol(Symbol sym, LambdaSymbolKind skind) {

  1229                 Map<Symbol, Symbol> transMap = null;

  1230                 String preferredName;

  1231                 switch (skind) {

  1232                     case CAPTURED_THIS:

  1233                         transMap = capturedThis;

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

  1235                         break;

  1236                     case CAPTURED_VAR:

  1237                         transMap = capturedLocals;

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

  1239                         break;

  1240                     case LOCAL_VAR:

  1241                         transMap = lambdaLocals;

  1242                         preferredName = sym.name.toString();

  1243                         break;

  1244                     case PARAM:

  1245                         transMap = lambdaParams;

  1246                         preferredName = sym.name.toString();

  1247                         break;

  1248                     default: throw new AssertionError();

  1249                 }

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

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

  1252                 }

  1253             }

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

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

  1257                 for (LambdaSymbolKind skind : skinds) {

  1258                     switch (skind) {

  1259                         case CAPTURED_THIS:

  1260                             translationMap.putAll(capturedThis);

  1261                             break;

  1262                         case CAPTURED_VAR:

  1263                             translationMap.putAll(capturedLocals);

  1264                             break;

  1265                         case LOCAL_VAR:

  1266                             translationMap.putAll(lambdaLocals);

  1267                             break;

  1268                         case PARAM:

  1269                             translationMap.putAll(lambdaParams);

  1270                             break;

  1271                         default: throw new AssertionError();

  1272                     }

  1273                 }

  1274                 return translationMap;

  1275             }

  1277             /**

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

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

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

  1281              * and full parameter list.

  1282              */

  1283             void complete() {

  1284                 if (syntheticParams != null) {

  1285                     return;

  1286                 }

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

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

  1289                 boolean needInstance = thisReferenced || inInterface;

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

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

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

  1295                 //compute synthetic params

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

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

  1299                 // synthetic parameters:

  1300                 //

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

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

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

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

  1305                 }

  1307                 syntheticParams = params.toList();

  1309                 //prepend synthetic args to translated lambda method signature

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

  1311                         (MethodType) generatedLambdaSig(),

  1312                         TreeInfo.types(syntheticParams));

  1313             }

  1315             Type enclosingType() {

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

  1317                 return owner.enclClass().type;

  1318             }

  1320             Type generatedLambdaSig() {

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

  1322             }

  1323         }

  1325         /**

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

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

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

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

  1330          */

  1331         private class ReferenceTranslationContext extends TranslationContext<JCMemberReference> {

  1333             final boolean isSuper;

  1334             final Symbol bridgeSym;

  1336             ReferenceTranslationContext(JCMemberReference tree) {

  1337                 super(tree);

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

  1339                 this.bridgeSym = needsBridge()

  1340                         ? makeSyntheticMethod(isSuper ? 0 : STATIC,

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

  1342                                               owner.enclClass())

  1343                         : null;

  1344             }

  1346             /**

  1347              * Get the opcode associated with this method reference

  1348              */

  1349             int referenceKind() {

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

  1351             }

  1353             boolean needsVarArgsConversion() {

  1354                 return tree.varargsElement != null;

  1355             }

  1357             /**

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

  1359              */

  1360             boolean isArrayOp() {

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

  1362             }

  1364             /**

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

  1366              * expanded or "super" is used)

  1367              */

  1368             final boolean needsBridge() {

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

  1370             }

  1372             Type generatedRefSig() {

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

  1374             }

  1376             Type bridgedRefSig() {

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

  1378             }

  1379         }

  1380     }

  1381     // </editor-fold>

  1383     enum LambdaSymbolKind {

  1384         CAPTURED_VAR,

  1385         CAPTURED_THIS,

  1386         LOCAL_VAR,

  1387         PARAM;

  1388     }

  1389 }

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

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

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