javac/comp/LambdaToMethod.java

75  * This pass desugars lambda expressions into static methods
100     /** map from lambda trees to translation contexts */
109     /** dump statistics about lambda code generation */
115     /** Flag for alternate metafactories indicating the lambda object is intended to be serializable */
118     /** Flag for alternate metafactories indicating the lambda object has multiple targets */
121     /** Flag for alternate metafactories indicating the lambda object requires multiple bridges */
185             deserParamSym = new VarSymbol(FINAL, names.fromString("lambda"),
258             for (JCTree lambda : newMethods) {
259                 tree.sym.members().enter(((JCMethodDecl)lambda).sym);
268      * Translate a lambda into a method to be inserted into the class.
269      * Then replace the lambda site with an invokedynamic call of to lambda
270      * meta-factory, which will use the lambda method.
279         {   /* Type annotation management: Based on where the lambda features, type annotations that
282                initializer is the lambda. In any event, gather up the annotations that belong to the
283                lambda and attach it to the implementation method.
310         //create the method declaration hoisting the lambda body
324         //translate lambda body
325         //As the lambda body is translated, all references to lambda locals,
334         //now that we have generated a method for the lambda expression,
335         //we can translate the lambda into a method reference pointing to the newly
343         // * enclosing locals captured by the lambda expression
379         // Reassign type annotations from the source that should really belong to the lambda
383                                               Consumer<List<Attribute.TypeCompound>> lambda) {
397                 lambda.accept(lambdaTypeAnnos.toList());
459      * Translate identifiers within a lambda to the mapped identifier
477                     //members defined inside the lambda body, etc.) )
487      * Translate qualified `this' references within a lambda to the mapped identifier
621             //there's no return statement and the lambda (possibly inferred)
645                     List.of(make.Literal("Invalid lambda deserialization"))))));
797      * as required by type-erasure - this is needed when bridging a lambda/method
813      * Converts a method reference which cannot be used directly into a lambda
831         JCLambda lambda() {
1183      * This visitor collects information about translation of a lambda expression.
1185      * accessed by the lambda being translated (as well as other useful info).
1194          * keep the count of lambda expression (used to generate unambiguous
1205          * keep the count of lambda expression defined in given context (used to
1227          * maps for fake clinit symbols to be used as owners of lambda occurring in
1296                         //if a class is defined within a lambda, the lambda must capture
1364             analyzeLambda(tree, "lambda.stat");
1485          * affected method references into a lambda containing a normal
1495                  // Convert to a lambda, and process as such
1497                 analyzeLambda(conv.lambda(), conv.getReceiverExpression());
1511                 // A select of this or super means, if we are in a lambda,
1537                 // If they occur within class nested in a lambda, mark for erasure
1559          * (required to skip synthetic lambda symbols)
1603                  * lambda expressions used as initializers of static fields, so
1674             // No lambda
1726          *  when translating away lambda expressions
1736          *  when translating away lambda expressions - at the moment, this is the
1791          * lambda expression/method references (see subclasses).
1798             /** points to the adjusted enclosing scope in which this lambda/mref expression occurs */
1801             /** the depth of this lambda expression in the frame stack */
1867          * This class retains all the useful information about a lambda expression;
1874             /** variable in the enclosing context to which this lambda is assigned */
1877             /** variable in the enclosing context to which this lambda is assigned */
1882             /** the synthetic symbol for the method hoisting the translated lambda */
1931              * For a serializable lambda, generate a disambiguating string
1934              * @return String to differentiate synthetic lambda method names
1940                 // lambdas, the generated lambda method will not have type yet,
1975              * For a non-serializable lambda, generate a simple method.
1977              * @return Name to use for the synthetic lambda method name
1980                 return names.lambda.append(names.fromString(enclosingMethodName() + "$" + lambdaCount++));
1984              * For a serializable lambda, generate a method name which maximizes
1987              * @return Name to use for the synthetic lambda method name
1991                 buf.append(names.lambda);
1992                 // Append the name of the method enclosing the lambda.
2010              * synthetic lambda body
2159                 // 1) reference to enclosing contexts captured by the lambda expression
2160                 // 2) enclosing locals captured by the lambda expression
2177                 // Compute and set the lambda name
2182                 //prepend synthetic args to translated lambda method signature
2285              * Does this reference need to be converted to a lambda
2313      * These keys provide mappings for various translated lambda symbols
2317         PARAM,          // original to translated lambda parameters
2318         LOCAL_VAR,      // original to translated lambda locals
2322         TYPE_VAR;      // original to translated lambda type variables