Wed, 13 Feb 2013 17:04:21 +0000
8006345: Report Synthesized Parameters in java.lang.reflect.Parameter API
8006896: ClassReader doesn't see MethodParameters attr for method of anon inner class
8007098: Output Synthesized Parameters to MethodParameters Attributes
Summary: Correctly report synthesized and mandated parameters
Reviewed-by: mcimadamore, jjg
Contributed-by: eric.mccorkle@oracle.com
1 /*
2 * Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package com.sun.tools.javac.comp;
27 import com.sun.tools.javac.tree.*;
28 import com.sun.tools.javac.tree.JCTree;
29 import com.sun.tools.javac.tree.JCTree.*;
30 import com.sun.tools.javac.tree.JCTree.JCMemberReference.ReferenceKind;
31 import com.sun.tools.javac.tree.TreeMaker;
32 import com.sun.tools.javac.tree.TreeScanner;
33 import com.sun.tools.javac.tree.TreeTranslator;
34 import com.sun.tools.javac.code.Flags;
35 import com.sun.tools.javac.code.Kinds;
36 import com.sun.tools.javac.code.Symbol;
37 import com.sun.tools.javac.code.Symbol.ClassSymbol;
38 import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol;
39 import com.sun.tools.javac.code.Symbol.MethodSymbol;
40 import com.sun.tools.javac.code.Symbol.VarSymbol;
41 import com.sun.tools.javac.code.Symtab;
42 import com.sun.tools.javac.code.Type;
43 import com.sun.tools.javac.code.Type.ClassType;
44 import com.sun.tools.javac.code.Type.MethodType;
45 import com.sun.tools.javac.code.Types;
46 import com.sun.tools.javac.comp.LambdaToMethod.LambdaAnalyzer.*;
47 import com.sun.tools.javac.jvm.*;
48 import com.sun.tools.javac.util.*;
49 import com.sun.tools.javac.util.List;
50 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
51 import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
53 import java.util.HashMap;
54 import java.util.LinkedHashMap;
55 import java.util.Map;
57 import static com.sun.tools.javac.comp.LambdaToMethod.LambdaSymbolKind.*;
58 import static com.sun.tools.javac.code.Flags.*;
59 import static com.sun.tools.javac.code.Kinds.*;
60 import static com.sun.tools.javac.code.TypeTag.BOT;
61 import static com.sun.tools.javac.code.TypeTag.NONE;
62 import static com.sun.tools.javac.code.TypeTag.VOID;
63 import static com.sun.tools.javac.tree.JCTree.Tag.*;
65 /**
66 * This pass desugars lambda expressions into static methods
67 *
68 * <p><b>This is NOT part of any supported API.
69 * If you write code that depends on this, you do so at your own risk.
70 * This code and its internal interfaces are subject to change or
71 * deletion without notice.</b>
72 */
73 public class LambdaToMethod extends TreeTranslator {
75 private Names names;
76 private Symtab syms;
77 private Resolve rs;
78 private TreeMaker make;
79 private Types types;
80 private TransTypes transTypes;
81 private Env<AttrContext> attrEnv;
83 /** the analyzer scanner */
84 private LambdaAnalyzer analyzer;
86 /** map from lambda trees to translation contexts */
87 private Map<JCTree, TranslationContext<?>> contextMap;
89 /** current translation context (visitor argument) */
90 private TranslationContext<?> context;
92 /** list of translated methods
93 **/
94 private ListBuffer<JCTree> translatedMethodList;
96 // <editor-fold defaultstate="collapsed" desc="Instantiating">
97 private static final Context.Key<LambdaToMethod> unlambdaKey =
98 new Context.Key<LambdaToMethod>();
100 public static LambdaToMethod instance(Context context) {
101 LambdaToMethod instance = context.get(unlambdaKey);
102 if (instance == null) {
103 instance = new LambdaToMethod(context);
104 }
105 return instance;
106 }
108 private LambdaToMethod(Context context) {
109 names = Names.instance(context);
110 syms = Symtab.instance(context);
111 rs = Resolve.instance(context);
112 make = TreeMaker.instance(context);
113 types = Types.instance(context);
114 transTypes = TransTypes.instance(context);
115 this.analyzer = makeAnalyzer();
116 }
118 private LambdaAnalyzer makeAnalyzer() {
119 return new LambdaAnalyzer();
120 }
121 // </editor-fold>
123 // <editor-fold defaultstate="collapsed" desc="translate methods">
124 @Override
125 public <T extends JCTree> T translate(T tree) {
126 TranslationContext<?> newContext = contextMap.get(tree);
127 return translate(tree, newContext != null ? newContext : context);
128 }
130 public <T extends JCTree> T translate(T tree, TranslationContext<?> newContext) {
131 TranslationContext<?> prevContext = context;
132 try {
133 context = newContext;
134 return super.translate(tree);
135 }
136 finally {
137 context = prevContext;
138 }
139 }
141 public <T extends JCTree> List<T> translate(List<T> trees, TranslationContext<?> newContext) {
142 ListBuffer<T> buf = ListBuffer.lb();
143 for (T tree : trees) {
144 buf.append(translate(tree, newContext));
145 }
146 return buf.toList();
147 }
149 public JCTree translateTopLevelClass(Env<AttrContext> env, JCTree cdef, TreeMaker make) {
150 this.make = make;
151 this.attrEnv = env;
152 this.context = null;
153 this.contextMap = new HashMap<JCTree, TranslationContext<?>>();
154 return translate(cdef);
155 }
156 // </editor-fold>
158 // <editor-fold defaultstate="collapsed" desc="visitor methods">
159 /**
160 * Visit a class.
161 * Maintain the translatedMethodList across nested classes.
162 * Append the translatedMethodList to the class after it is translated.
163 * @param tree
164 */
165 @Override
166 public void visitClassDef(JCClassDecl tree) {
167 if (tree.sym.owner.kind == PCK) {
168 //analyze class
169 analyzer.analyzeClass(tree);
170 }
171 ListBuffer<JCTree> prevTranslated = translatedMethodList;
172 try {
173 translatedMethodList = ListBuffer.lb();
174 super.visitClassDef(tree);
175 //add all translated instance methods here
176 tree.defs = tree.defs.appendList(translatedMethodList.toList());
177 for (JCTree lambda : translatedMethodList) {
178 tree.sym.members().enter(((JCMethodDecl)lambda).sym);
179 }
180 result = tree;
181 } finally {
182 translatedMethodList = prevTranslated;
183 }
184 }
186 /**
187 * Translate a lambda into a method to be inserted into the class.
188 * Then replace the lambda site with an invokedynamic call of to lambda
189 * meta-factory, which will use the lambda method.
190 * @param tree
191 */
192 @Override
193 public void visitLambda(JCLambda tree) {
194 LambdaTranslationContext localContext = (LambdaTranslationContext)context;
195 MethodSymbol sym = (MethodSymbol)localContext.translatedSym;
196 MethodType lambdaType = (MethodType) sym.type;
198 //create the method declaration hoisting the lambda body
199 JCMethodDecl lambdaDecl = make.MethodDef(make.Modifiers(sym.flags_field),
200 sym.name,
201 make.QualIdent(lambdaType.getReturnType().tsym),
202 List.<JCTypeParameter>nil(),
203 localContext.syntheticParams,
204 lambdaType.getThrownTypes() == null ?
205 List.<JCExpression>nil() :
206 make.Types(lambdaType.getThrownTypes()),
207 null,
208 null);
209 lambdaDecl.sym = sym;
210 lambdaDecl.type = lambdaType;
212 //translate lambda body
213 //As the lambda body is translated, all references to lambda locals,
214 //captured variables, enclosing members are adjusted accordingly
215 //to refer to the static method parameters (rather than i.e. acessing to
216 //captured members directly).
217 lambdaDecl.body = translate(makeLambdaBody(tree, lambdaDecl));
219 //Add the method to the list of methods to be added to this class.
220 translatedMethodList = translatedMethodList.prepend(lambdaDecl);
222 //now that we have generated a method for the lambda expression,
223 //we can translate the lambda into a method reference pointing to the newly
224 //created method.
225 //
226 //Note that we need to adjust the method handle so that it will match the
227 //signature of the SAM descriptor - this means that the method reference
228 //should be added the following synthetic arguments:
229 //
230 // * the "this" argument if it is an instance method
231 // * enclosing locals captured by the lambda expression
233 ListBuffer<JCExpression> syntheticInits = ListBuffer.lb();
235 if (!sym.isStatic()) {
236 syntheticInits.append(makeThis(
237 sym.owner.asType(),
238 localContext.owner.enclClass()));
239 }
241 //add captured locals
242 for (Symbol fv : localContext.getSymbolMap(CAPTURED_VAR).keySet()) {
243 if (fv != localContext.self) {
244 JCTree captured_local = make.Ident(fv).setType(fv.type);
245 syntheticInits.append((JCExpression) captured_local);
246 }
247 }
249 //then, determine the arguments to the indy call
250 List<JCExpression> indy_args = translate(syntheticInits.toList(), localContext.prev);
252 //build a sam instance using an indy call to the meta-factory
253 int refKind = referenceKind(sym);
255 //convert to an invokedynamic call
256 result = makeMetaFactoryIndyCall(tree, refKind, sym, indy_args);
257 }
259 private JCIdent makeThis(Type type, Symbol owner) {
260 VarSymbol _this = new VarSymbol(PARAMETER | FINAL | SYNTHETIC,
261 names._this,
262 type,
263 owner);
264 return make.Ident(_this);
265 }
267 /**
268 * Translate a method reference into an invokedynamic call to the
269 * meta-factory.
270 * @param tree
271 */
272 @Override
273 public void visitReference(JCMemberReference tree) {
274 ReferenceTranslationContext localContext = (ReferenceTranslationContext)context;
276 //first determine the method symbol to be used to generate the sam instance
277 //this is either the method reference symbol, or the bridged reference symbol
278 Symbol refSym = localContext.needsBridge() ?
279 localContext.bridgeSym :
280 tree.sym;
282 //build the bridge method, if needed
283 if (localContext.needsBridge()) {
284 bridgeMemberReference(tree, localContext);
285 }
287 //the qualifying expression is treated as a special captured arg
288 JCExpression init;
289 switch(tree.kind) {
291 case IMPLICIT_INNER: /** Inner :: new */
292 case SUPER: /** super :: instMethod */
293 init = makeThis(
294 localContext.owner.owner.asType(),
295 localContext.owner);
296 break;
298 case BOUND: /** Expr :: instMethod */
299 init = tree.getQualifierExpression();
300 break;
302 case UNBOUND: /** Type :: instMethod */
303 case STATIC: /** Type :: staticMethod */
304 case TOPLEVEL: /** Top level :: new */
305 case ARRAY_CTOR: /** ArrayType :: new */
306 init = null;
307 break;
309 default:
310 throw new InternalError("Should not have an invalid kind");
311 }
313 List<JCExpression> indy_args = init==null? List.<JCExpression>nil() : translate(List.of(init), localContext.prev);
316 //build a sam instance using an indy call to the meta-factory
317 result = makeMetaFactoryIndyCall(tree, localContext.referenceKind(), refSym, indy_args);
318 }
320 /**
321 * Translate identifiers within a lambda to the mapped identifier
322 * @param tree
323 */
324 @Override
325 public void visitIdent(JCIdent tree) {
326 if (context == null || !analyzer.lambdaIdentSymbolFilter(tree.sym)) {
327 super.visitIdent(tree);
328 } else {
329 LambdaTranslationContext lambdaContext = (LambdaTranslationContext) context;
330 if (lambdaContext.getSymbolMap(PARAM).containsKey(tree.sym)) {
331 Symbol translatedSym = lambdaContext.getSymbolMap(PARAM).get(tree.sym);
332 result = make.Ident(translatedSym).setType(tree.type);
333 } else if (lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {
334 Symbol translatedSym = lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym);
335 result = make.Ident(translatedSym).setType(tree.type);
336 } else if (lambdaContext.getSymbolMap(CAPTURED_VAR).containsKey(tree.sym)) {
337 Symbol translatedSym = lambdaContext.getSymbolMap(CAPTURED_VAR).get(tree.sym);
338 result = make.Ident(translatedSym).setType(tree.type);
339 } else {
340 if (tree.sym.owner.kind == Kinds.TYP) {
341 for (Map.Entry<Symbol, Symbol> encl_entry : lambdaContext.getSymbolMap(CAPTURED_THIS).entrySet()) {
342 if (tree.sym.isMemberOf((ClassSymbol) encl_entry.getKey(), types)) {
343 JCExpression enclRef = make.Ident(encl_entry.getValue());
344 result = tree.sym.name == names._this
345 ? enclRef.setType(tree.type)
346 : make.Select(enclRef, tree.sym).setType(tree.type);
347 result = tree;
348 return;
349 }
350 }
351 }
352 //access to untranslated symbols (i.e. compile-time constants,
353 //members defined inside the lambda body, etc.) )
354 super.visitIdent(tree);
355 }
356 }
357 }
359 @Override
360 public void visitVarDef(JCVariableDecl tree) {
361 LambdaTranslationContext lambdaContext = (LambdaTranslationContext)context;
362 if (context != null && lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {
363 JCExpression init = translate(tree.init);
364 result = make.VarDef((VarSymbol)lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym), init);
365 } else {
366 super.visitVarDef(tree);
367 }
368 }
370 // </editor-fold>
372 // <editor-fold defaultstate="collapsed" desc="Translation helper methods">
374 private JCBlock makeLambdaBody(JCLambda tree, JCMethodDecl lambdaMethodDecl) {
375 return tree.getBodyKind() == JCLambda.BodyKind.EXPRESSION ?
376 makeLambdaExpressionBody((JCExpression)tree.body, lambdaMethodDecl) :
377 makeLambdaStatementBody((JCBlock)tree.body, lambdaMethodDecl, tree.canCompleteNormally);
378 }
380 private JCBlock makeLambdaExpressionBody(JCExpression expr, JCMethodDecl lambdaMethodDecl) {
381 Type restype = lambdaMethodDecl.type.getReturnType();
382 boolean isLambda_void = expr.type.hasTag(VOID);
383 boolean isTarget_void = restype.hasTag(VOID);
384 boolean isTarget_Void = types.isSameType(restype, types.boxedClass(syms.voidType).type);
385 if (isTarget_void) {
386 //target is void:
387 // BODY;
388 JCStatement stat = make.Exec(expr);
389 return make.Block(0, List.<JCStatement>of(stat));
390 } else if (isLambda_void && isTarget_Void) {
391 //void to Void conversion:
392 // BODY; return null;
393 ListBuffer<JCStatement> stats = ListBuffer.lb();
394 stats.append(make.Exec(expr));
395 stats.append(make.Return(make.Literal(BOT, null).setType(syms.botType)));
396 return make.Block(0, stats.toList());
397 } else {
398 //non-void to non-void conversion:
399 // return (TYPE)BODY;
400 JCExpression retExpr = transTypes.coerce(attrEnv, expr, restype);
401 return make.Block(0, List.<JCStatement>of(make.Return(retExpr)));
402 }
403 }
405 private JCBlock makeLambdaStatementBody(JCBlock block, final JCMethodDecl lambdaMethodDecl, boolean completeNormally) {
406 final Type restype = lambdaMethodDecl.type.getReturnType();
407 final boolean isTarget_void = restype.hasTag(VOID);
408 boolean isTarget_Void = types.isSameType(restype, types.boxedClass(syms.voidType).type);
410 class LambdaBodyTranslator extends TreeTranslator {
412 @Override
413 public void visitClassDef(JCClassDecl tree) {
414 //do NOT recurse on any inner classes
415 result = tree;
416 }
418 @Override
419 public void visitLambda(JCLambda tree) {
420 //do NOT recurse on any nested lambdas
421 result = tree;
422 }
424 @Override
425 public void visitReturn(JCReturn tree) {
426 boolean isLambda_void = tree.expr == null;
427 if (isTarget_void && !isLambda_void) {
428 //Void to void conversion:
429 // { TYPE $loc = RET-EXPR; return; }
430 VarSymbol loc = makeSyntheticVar(0, names.fromString("$loc"), tree.expr.type, lambdaMethodDecl.sym);
431 JCVariableDecl varDef = make.VarDef(loc, tree.expr);
432 result = make.Block(0, List.<JCStatement>of(varDef, make.Return(null)));
433 } else if (!isTarget_void || !isLambda_void) {
434 //non-void to non-void conversion:
435 // return (TYPE)RET-EXPR;
436 tree.expr = transTypes.coerce(attrEnv, tree.expr, restype);
437 result = tree;
438 } else {
439 result = tree;
440 }
442 }
443 }
445 JCBlock trans_block = new LambdaBodyTranslator().translate(block);
446 if (completeNormally && isTarget_Void) {
447 //there's no return statement and the lambda (possibly inferred)
448 //return type is java.lang.Void; emit a synthetic return statement
449 trans_block.stats = trans_block.stats.append(make.Return(make.Literal(BOT, null).setType(syms.botType)));
450 }
451 return trans_block;
452 }
454 /**
455 * Create new synthetic method with given flags, name, type, owner
456 */
457 private MethodSymbol makeSyntheticMethod(long flags, Name name, Type type, Symbol owner) {
458 return new MethodSymbol(flags | SYNTHETIC, name, type, owner);
459 }
461 /**
462 * Create new synthetic variable with given flags, name, type, owner
463 */
464 private VarSymbol makeSyntheticVar(long flags, String name, Type type, Symbol owner) {
465 return makeSyntheticVar(flags, names.fromString(name), type, owner);
466 }
468 /**
469 * Create new synthetic variable with given flags, name, type, owner
470 */
471 private VarSymbol makeSyntheticVar(long flags, Name name, Type type, Symbol owner) {
472 return new VarSymbol(flags | SYNTHETIC, name, type, owner);
473 }
475 /**
476 * Set varargsElement field on a given tree (must be either a new class tree
477 * or a method call tree)
478 */
479 private void setVarargsIfNeeded(JCTree tree, Type varargsElement) {
480 if (varargsElement != null) {
481 switch (tree.getTag()) {
482 case APPLY: ((JCMethodInvocation)tree).varargsElement = varargsElement; break;
483 case NEWCLASS: ((JCNewClass)tree).varargsElement = varargsElement; break;
484 default: throw new AssertionError();
485 }
486 }
487 }
489 /**
490 * Convert method/constructor arguments by inserting appropriate cast
491 * as required by type-erasure - this is needed when bridging a lambda/method
492 * reference, as the bridged signature might require downcast to be compatible
493 * with the generated signature.
494 */
495 private List<JCExpression> convertArgs(Symbol meth, List<JCExpression> args, Type varargsElement) {
496 Assert.check(meth.kind == Kinds.MTH);
497 List<Type> formals = types.erasure(meth.type).getParameterTypes();
498 if (varargsElement != null) {
499 Assert.check((meth.flags() & VARARGS) != 0);
500 }
501 return transTypes.translateArgs(args, formals, varargsElement, attrEnv);
502 }
504 // </editor-fold>
506 /**
507 * Generate an adapter method "bridge" for a method reference which cannot
508 * be used directly.
509 */
510 private class MemberReferenceBridger {
512 private final JCMemberReference tree;
513 private final ReferenceTranslationContext localContext;
514 private final ListBuffer<JCExpression> args = ListBuffer.lb();
515 private final ListBuffer<JCVariableDecl> params = ListBuffer.lb();
517 MemberReferenceBridger(JCMemberReference tree, ReferenceTranslationContext localContext) {
518 this.tree = tree;
519 this.localContext = localContext;
520 }
522 /**
523 * Generate the bridge
524 */
525 JCMethodDecl bridge() {
526 int prevPos = make.pos;
527 try {
528 make.at(tree);
529 Type samDesc = localContext.bridgedRefSig();
530 List<Type> samPTypes = samDesc.getParameterTypes();
532 //an extra argument is prepended to the signature of the bridge in case
533 //the member reference is an instance method reference (in which case
534 //the receiver expression is passed to the bridge itself).
535 Type recType = null;
536 switch (tree.kind) {
537 case IMPLICIT_INNER:
538 recType = tree.sym.owner.type.getEnclosingType();
539 break;
540 case BOUND:
541 recType = tree.getQualifierExpression().type;
542 break;
543 case UNBOUND:
544 recType = samPTypes.head;
545 samPTypes = samPTypes.tail;
546 break;
547 }
549 //generate the parameter list for the bridged member reference - the
550 //bridge signature will match the signature of the target sam descriptor
552 VarSymbol rcvr = (recType == null)
553 ? null
554 : addParameter("rec$", recType, false);
556 List<Type> refPTypes = tree.sym.type.getParameterTypes();
557 int refSize = refPTypes.size();
558 int samSize = samPTypes.size();
559 int last = localContext.needsVarArgsConversion() ? refSize - 1 : refSize; // Last parameter to copy from referenced method
561 List<Type> l = refPTypes;
562 // Use parameter types of the referenced method, excluding final var args
563 for (int i = 0; l.nonEmpty() && i < last; ++i) {
564 addParameter("x$" + i, l.head, true);
565 l = l.tail;
566 }
567 // Flatten out the var args
568 for (int i = last; i < samSize; ++i) {
569 addParameter("xva$" + i, tree.varargsElement, true);
570 }
572 //generate the bridge method declaration
573 JCMethodDecl bridgeDecl = make.MethodDef(make.Modifiers(localContext.bridgeSym.flags()),
574 localContext.bridgeSym.name,
575 make.QualIdent(samDesc.getReturnType().tsym),
576 List.<JCTypeParameter>nil(),
577 params.toList(),
578 tree.sym.type.getThrownTypes() == null
579 ? List.<JCExpression>nil()
580 : make.Types(tree.sym.type.getThrownTypes()),
581 null,
582 null);
583 bridgeDecl.sym = (MethodSymbol) localContext.bridgeSym;
584 bridgeDecl.type = localContext.bridgeSym.type = types.createMethodTypeWithParameters(samDesc, TreeInfo.types(params.toList()));
586 //bridge method body generation - this can be either a method call or a
587 //new instance creation expression, depending on the member reference kind
588 JCExpression bridgeExpr = (tree.getMode() == ReferenceMode.INVOKE)
589 ? bridgeExpressionInvoke(rcvr)
590 : bridgeExpressionNew();
592 //the body is either a return expression containing a method call,
593 //or the method call itself, depending on whether the return type of
594 //the bridge is non-void/void.
595 bridgeDecl.body = makeLambdaExpressionBody(bridgeExpr, bridgeDecl);
597 return bridgeDecl;
598 } finally {
599 make.at(prevPos);
600 }
601 }
603 /**
604 * determine the receiver of the bridged method call - the receiver can
605 * be either the synthetic receiver parameter or a type qualifier; the
606 * original qualifier expression is never used here, as it might refer
607 * to symbols not available in the static context of the bridge
608 */
609 private JCExpression bridgeExpressionInvoke(VarSymbol rcvr) {
610 JCExpression qualifier =
611 tree.sym.isStatic() ?
612 make.Type(tree.sym.owner.type) :
613 (rcvr != null) ?
614 make.Ident(rcvr) :
615 tree.getQualifierExpression();
617 //create the qualifier expression
618 JCFieldAccess select = make.Select(qualifier, tree.sym.name);
619 select.sym = tree.sym;
620 select.type = tree.sym.erasure(types);
622 //create the method call expression
623 JCExpression apply = make.Apply(List.<JCExpression>nil(), select,
624 convertArgs(tree.sym, args.toList(), tree.varargsElement)).setType(tree.sym.erasure(types).getReturnType());
626 apply = transTypes.coerce(apply, localContext.generatedRefSig().getReturnType());
627 setVarargsIfNeeded(apply, tree.varargsElement);
628 return apply;
629 }
631 /**
632 * the enclosing expression is either 'null' (no enclosing type) or set
633 * to the first bridge synthetic parameter
634 */
635 private JCExpression bridgeExpressionNew() {
636 if (tree.kind == ReferenceKind.ARRAY_CTOR) {
637 //create the array creation expression
638 JCNewArray newArr = make.NewArray(make.Type(types.elemtype(tree.getQualifierExpression().type)),
639 List.of(make.Ident(params.first())),
640 null);
641 newArr.type = tree.getQualifierExpression().type;
642 return newArr;
643 } else {
644 JCExpression encl = null;
645 switch (tree.kind) {
646 case UNBOUND:
647 case IMPLICIT_INNER:
648 encl = make.Ident(params.first());
649 }
651 //create the instance creation expression
652 JCNewClass newClass = make.NewClass(encl,
653 List.<JCExpression>nil(),
654 make.Type(tree.getQualifierExpression().type),
655 convertArgs(tree.sym, args.toList(), tree.varargsElement),
656 null);
657 newClass.constructor = tree.sym;
658 newClass.constructorType = tree.sym.erasure(types);
659 newClass.type = tree.getQualifierExpression().type;
660 setVarargsIfNeeded(newClass, tree.varargsElement);
661 return newClass;
662 }
663 }
665 private VarSymbol addParameter(String name, Type p, boolean genArg) {
666 VarSymbol vsym = new VarSymbol(0, names.fromString(name), p, localContext.bridgeSym);
667 params.append(make.VarDef(vsym, null));
668 if (genArg) {
669 args.append(make.Ident(vsym));
670 }
671 return vsym;
672 }
673 }
675 /**
676 * Bridges a member reference - this is needed when:
677 * * Var args in the referenced method need to be flattened away
678 * * super is used
679 */
680 private void bridgeMemberReference(JCMemberReference tree, ReferenceTranslationContext localContext) {
681 JCMethodDecl bridgeDecl = (new MemberReferenceBridger(tree, localContext).bridge());
682 translatedMethodList = translatedMethodList.prepend(bridgeDecl);
683 }
685 /**
686 * Generate an indy method call to the meta factory
687 */
688 private JCExpression makeMetaFactoryIndyCall(JCFunctionalExpression tree, int refKind, Symbol refSym, List<JCExpression> indy_args) {
689 //determine the static bsm args
690 Type mtype = types.erasure(tree.descriptorType);
691 MethodSymbol samSym = (MethodSymbol) types.findDescriptorSymbol(tree.type.tsym);
692 List<Object> staticArgs = List.<Object>of(
693 new Pool.MethodHandle(ClassFile.REF_invokeInterface, types.findDescriptorSymbol(tree.type.tsym), types),
694 new Pool.MethodHandle(refKind, refSym, types),
695 new MethodType(mtype.getParameterTypes(),
696 mtype.getReturnType(),
697 mtype.getThrownTypes(),
698 syms.methodClass));
700 //computed indy arg types
701 ListBuffer<Type> indy_args_types = ListBuffer.lb();
702 for (JCExpression arg : indy_args) {
703 indy_args_types.append(arg.type);
704 }
706 //finally, compute the type of the indy call
707 MethodType indyType = new MethodType(indy_args_types.toList(),
708 tree.type,
709 List.<Type>nil(),
710 syms.methodClass);
712 return makeIndyCall(tree, syms.lambdaMetafactory, names.metaFactory, staticArgs, indyType, indy_args);
713 }
715 /**
716 * Generate an indy method call with given name, type and static bootstrap
717 * arguments types
718 */
719 private JCExpression makeIndyCall(DiagnosticPosition pos, Type site, Name bsmName, List<Object> staticArgs, MethodType indyType, List<JCExpression> indyArgs) {
720 int prevPos = make.pos;
721 try {
722 make.at(pos);
723 List<Type> bsm_staticArgs = List.of(syms.methodHandleLookupType,
724 syms.stringType,
725 syms.methodTypeType).appendList(bsmStaticArgToTypes(staticArgs));
727 Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site,
728 bsmName, bsm_staticArgs, List.<Type>nil());
730 DynamicMethodSymbol dynSym =
731 new DynamicMethodSymbol(names.lambda,
732 syms.noSymbol,
733 bsm.isStatic() ? ClassFile.REF_invokeStatic : ClassFile.REF_invokeVirtual,
734 (MethodSymbol)bsm,
735 indyType,
736 staticArgs.toArray());
738 JCFieldAccess qualifier = make.Select(make.QualIdent(site.tsym), bsmName);
739 qualifier.sym = dynSym;
740 qualifier.type = indyType.getReturnType();
742 JCMethodInvocation proxyCall = make.Apply(List.<JCExpression>nil(), qualifier, indyArgs);
743 proxyCall.type = indyType.getReturnType();
744 return proxyCall;
745 } finally {
746 make.at(prevPos);
747 }
748 }
749 //where
750 private List<Type> bsmStaticArgToTypes(List<Object> args) {
751 ListBuffer<Type> argtypes = ListBuffer.lb();
752 for (Object arg : args) {
753 argtypes.append(bsmStaticArgToType(arg));
754 }
755 return argtypes.toList();
756 }
758 private Type bsmStaticArgToType(Object arg) {
759 Assert.checkNonNull(arg);
760 if (arg instanceof ClassSymbol) {
761 return syms.classType;
762 } else if (arg instanceof Integer) {
763 return syms.intType;
764 } else if (arg instanceof Long) {
765 return syms.longType;
766 } else if (arg instanceof Float) {
767 return syms.floatType;
768 } else if (arg instanceof Double) {
769 return syms.doubleType;
770 } else if (arg instanceof String) {
771 return syms.stringType;
772 } else if (arg instanceof Pool.MethodHandle) {
773 return syms.methodHandleType;
774 } else if (arg instanceof MethodType) {
775 return syms.methodTypeType;
776 } else {
777 Assert.error("bad static arg " + arg.getClass());
778 return null;
779 }
780 }
782 /**
783 * Get the opcode associated with this method reference
784 */
785 private int referenceKind(Symbol refSym) {
786 if (refSym.isConstructor()) {
787 return ClassFile.REF_newInvokeSpecial;
788 } else {
789 if (refSym.isStatic()) {
790 return ClassFile.REF_invokeStatic;
791 } else if (refSym.enclClass().isInterface()) {
792 return ClassFile.REF_invokeInterface;
793 } else {
794 return ClassFile.REF_invokeVirtual;
795 }
796 }
797 }
798 // </editor-fold>
800 // <editor-fold defaultstate="collapsed" desc="Lambda/reference analyzer">\
801 /**
802 * This visitor collects information about translation of a lambda expression.
803 * More specifically, it keeps track of the enclosing contexts and captured locals
804 * accessed by the lambda being translated (as well as other useful info).
805 */
806 class LambdaAnalyzer extends TreeScanner {
808 /** the frame stack - used to reconstruct translation info about enclosing scopes */
809 private List<Frame> frameStack;
811 /**
812 * keep the count of lambda expression (used to generate unambiguous
813 * names)
814 */
815 private int lambdaCount = 0;
817 private void analyzeClass(JCClassDecl tree) {
818 frameStack = List.nil();
819 scan(tree);
820 }
822 @Override
823 public void visitBlock(JCBlock tree) {
824 List<Frame> prevStack = frameStack;
825 try {
826 if (frameStack.nonEmpty() && frameStack.head.tree.hasTag(CLASSDEF)) {
827 frameStack = frameStack.prepend(new Frame(tree));
828 }
829 super.visitBlock(tree);
830 }
831 finally {
832 frameStack = prevStack;
833 }
834 }
836 @Override
837 public void visitClassDef(JCClassDecl tree) {
838 List<Frame> prevStack = frameStack;
839 try {
840 if (frameStack.nonEmpty() && enclosingLambda() != null) {
841 tree.sym.owner = owner();
842 LambdaTranslationContext lambdaContext = (LambdaTranslationContext)contextMap.get(enclosingLambda());
843 Type encl = lambdaContext.enclosingType();
844 if (encl.hasTag(NONE)) {
845 //if the translated lambda body occurs in a static context,
846 //any class declaration within it must be made static
847 tree.sym.flags_field |= STATIC;
848 ((ClassType)tree.sym.type).setEnclosingType(Type.noType);
849 } else {
850 //if the translated lambda body is in an instance context
851 //the enclosing type of any class declaration within it
852 //must be updated to point to the new enclosing type (if any)
853 ((ClassType)tree.sym.type).setEnclosingType(encl);
854 }
855 }
856 frameStack = frameStack.prepend(new Frame(tree));
857 super.visitClassDef(tree);
858 }
859 finally {
860 frameStack = prevStack;
861 }
862 if (!tree.sym.isStatic() && frameStack.nonEmpty() && enclosingLambda() != null) {
863 // Any (non-static) class defined within a lambda is an implicit 'this' reference
864 // because its constructor will reference the enclosing class
865 ((LambdaTranslationContext) context()).addSymbol(tree.sym.type.getEnclosingType().tsym, CAPTURED_THIS);
866 }
867 }
869 @Override
870 public void visitIdent(JCIdent tree) {
871 if (context() == null || !lambdaIdentSymbolFilter(tree.sym)) {
872 super.visitIdent(tree);
873 } else {
874 if (tree.sym.kind == VAR &&
875 tree.sym.owner.kind == MTH &&
876 tree.type.constValue() == null) {
877 TranslationContext<?> localContext = context();
878 while (localContext != null) {
879 if (localContext.tree.getTag() == LAMBDA) {
880 JCTree block = capturedDecl(localContext.depth, tree.sym);
881 if (block == null) break;
882 ((LambdaTranslationContext)localContext).addSymbol(tree.sym, CAPTURED_VAR);
883 }
884 localContext = localContext.prev;
885 }
886 } else if (tree.sym.owner.kind == TYP) {
887 TranslationContext<?> localContext = context();
888 while (localContext != null) {
889 if (localContext.tree.hasTag(LAMBDA)) {
890 JCTree block = capturedDecl(localContext.depth, tree.sym);
891 if (block == null) break;
892 switch (block.getTag()) {
893 case CLASSDEF:
894 JCClassDecl cdecl = (JCClassDecl)block;
895 ((LambdaTranslationContext)localContext).addSymbol(cdecl.sym, CAPTURED_THIS);
896 break;
897 default:
898 Assert.error("bad block kind");
899 }
900 }
901 localContext = localContext.prev;
902 }
903 }
904 }
905 }
907 @Override
908 public void visitLambda(JCLambda tree) {
909 List<Frame> prevStack = frameStack;
910 try {
911 LambdaTranslationContext context = (LambdaTranslationContext)makeLambdaContext(tree);
912 frameStack = frameStack.prepend(new Frame(tree));
913 for (JCVariableDecl param : tree.params) {
914 context.addSymbol(param.sym, PARAM);
915 frameStack.head.addLocal(param.sym);
916 }
917 contextMap.put(tree, context);
918 scan(tree.body);
919 context.complete();
920 }
921 finally {
922 frameStack = prevStack;
923 }
924 }
926 @Override
927 public void visitMethodDef(JCMethodDecl tree) {
928 List<Frame> prevStack = frameStack;
929 try {
930 frameStack = frameStack.prepend(new Frame(tree));
931 super.visitMethodDef(tree);
932 }
933 finally {
934 frameStack = prevStack;
935 }
936 }
938 @Override
939 public void visitNewClass(JCNewClass tree) {
940 if (lambdaNewClassFilter(context(), tree)) {
941 ((LambdaTranslationContext) context()).addSymbol(tree.type.getEnclosingType().tsym, CAPTURED_THIS);
942 }
943 super.visitNewClass(tree);
944 }
946 @Override
947 public void visitReference(JCMemberReference tree) {
948 scan(tree.getQualifierExpression());
949 contextMap.put(tree, makeReferenceContext(tree));
950 }
952 @Override
953 public void visitSelect(JCFieldAccess tree) {
954 if (context() != null && lambdaSelectSymbolFilter(tree.sym)) {
955 TranslationContext<?> localContext = context();
956 while (localContext != null) {
957 if (localContext.tree.hasTag(LAMBDA)) {
958 JCClassDecl clazz = (JCClassDecl)capturedDecl(localContext.depth, tree.sym);
959 if (clazz == null) break;
960 ((LambdaTranslationContext)localContext).addSymbol(clazz.sym, CAPTURED_THIS);
961 }
962 localContext = localContext.prev;
963 }
964 scan(tree.selected);
965 } else {
966 super.visitSelect(tree);
967 }
968 }
970 @Override
971 public void visitVarDef(JCVariableDecl tree) {
972 if (frameStack.head.tree.hasTag(LAMBDA)) {
973 ((LambdaTranslationContext)context()).addSymbol(tree.sym, LOCAL_VAR);
974 }
975 List<Frame> prevStack = frameStack;
976 try {
977 if (tree.sym.owner.kind == MTH) {
978 frameStack.head.addLocal(tree.sym);
979 }
980 frameStack = frameStack.prepend(new Frame(tree));
981 super.visitVarDef(tree);
982 }
983 finally {
984 frameStack = prevStack;
985 }
986 }
988 private Name lambdaName() {
989 return names.lambda.append(names.fromString("$" + lambdaCount++));
990 }
992 /**
993 * Return a valid owner given the current declaration stack
994 * (required to skip synthetic lambda symbols)
995 */
996 private Symbol owner() {
997 return owner(false);
998 }
1000 @SuppressWarnings("fallthrough")
1001 private Symbol owner(boolean skipLambda) {
1002 List<Frame> frameStack2 = frameStack;
1003 while (frameStack2.nonEmpty()) {
1004 switch (frameStack2.head.tree.getTag()) {
1005 case VARDEF:
1006 if (((JCVariableDecl)frameStack2.head.tree).sym.isLocal()) {
1007 frameStack2 = frameStack2.tail;
1008 break;
1009 }
1010 JCClassDecl cdecl = (JCClassDecl)frameStack2.tail.head.tree;
1011 return makeSyntheticMethod(((JCVariableDecl)frameStack2.head.tree).sym.flags() & STATIC, names.empty, null, cdecl.sym);
1012 case BLOCK:
1013 JCClassDecl cdecl2 = (JCClassDecl)frameStack2.tail.head.tree;
1014 return makeSyntheticMethod(((JCBlock)frameStack2.head.tree).flags & STATIC | Flags.BLOCK, names.empty, null, cdecl2.sym);
1015 case CLASSDEF:
1016 return ((JCClassDecl)frameStack2.head.tree).sym;
1017 case METHODDEF:
1018 return ((JCMethodDecl)frameStack2.head.tree).sym;
1019 case LAMBDA:
1020 if (!skipLambda)
1021 return ((LambdaTranslationContext)contextMap.get(frameStack2.head.tree)).translatedSym;
1022 default:
1023 frameStack2 = frameStack2.tail;
1024 }
1025 }
1026 Assert.error();
1027 return null;
1028 }
1030 private JCTree enclosingLambda() {
1031 List<Frame> frameStack2 = frameStack;
1032 while (frameStack2.nonEmpty()) {
1033 switch (frameStack2.head.tree.getTag()) {
1034 case CLASSDEF:
1035 case METHODDEF:
1036 return null;
1037 case LAMBDA:
1038 return frameStack2.head.tree;
1039 default:
1040 frameStack2 = frameStack2.tail;
1041 }
1042 }
1043 Assert.error();
1044 return null;
1045 }
1047 /**
1048 * Return the declaration corresponding to a symbol in the enclosing
1049 * scope; the depth parameter is used to filter out symbols defined
1050 * in nested scopes (which do not need to undergo capture).
1051 */
1052 private JCTree capturedDecl(int depth, Symbol sym) {
1053 int currentDepth = frameStack.size() - 1;
1054 for (Frame block : frameStack) {
1055 switch (block.tree.getTag()) {
1056 case CLASSDEF:
1057 ClassSymbol clazz = ((JCClassDecl)block.tree).sym;
1058 if (sym.isMemberOf(clazz, types)) {
1059 return currentDepth > depth ? null : block.tree;
1060 }
1061 break;
1062 case VARDEF:
1063 if (((JCVariableDecl)block.tree).sym == sym &&
1064 sym.owner.kind == MTH) { //only locals are captured
1065 return currentDepth > depth ? null : block.tree;
1066 }
1067 break;
1068 case BLOCK:
1069 case METHODDEF:
1070 case LAMBDA:
1071 if (block.locals != null && block.locals.contains(sym)) {
1072 return currentDepth > depth ? null : block.tree;
1073 }
1074 break;
1075 default:
1076 Assert.error("bad decl kind " + block.tree.getTag());
1077 }
1078 currentDepth--;
1079 }
1080 return null;
1081 }
1083 private TranslationContext<?> context() {
1084 for (Frame frame : frameStack) {
1085 TranslationContext<?> context = contextMap.get(frame.tree);
1086 if (context != null) {
1087 return context;
1088 }
1089 }
1090 return null;
1091 }
1093 /**
1094 * This is used to filter out those identifiers that needs to be adjusted
1095 * when translating away lambda expressions
1096 */
1097 private boolean lambdaIdentSymbolFilter(Symbol sym) {
1098 return (sym.kind == VAR || sym.kind == MTH)
1099 && !sym.isStatic()
1100 && sym.name != names.init;
1101 }
1103 private boolean lambdaSelectSymbolFilter(Symbol sym) {
1104 return (sym.kind == VAR || sym.kind == MTH) &&
1105 !sym.isStatic() &&
1106 (sym.name == names._this ||
1107 sym.name == names._super);
1108 }
1110 /**
1111 * This is used to filter out those new class expressions that need to
1112 * be qualified with an enclosing tree
1113 */
1114 private boolean lambdaNewClassFilter(TranslationContext<?> context, JCNewClass tree) {
1115 if (context != null
1116 && tree.encl == null
1117 && tree.def == null
1118 && !tree.type.getEnclosingType().hasTag(NONE)) {
1119 Type encl = tree.type.getEnclosingType();
1120 Type current = context.owner.enclClass().type;
1121 while (!current.hasTag(NONE)) {
1122 if (current.tsym.isSubClass(encl.tsym, types)) {
1123 return true;
1124 }
1125 current = current.getEnclosingType();
1126 }
1127 return false;
1128 } else {
1129 return false;
1130 }
1131 }
1133 private TranslationContext<JCLambda> makeLambdaContext(JCLambda tree) {
1134 return new LambdaTranslationContext(tree);
1135 }
1137 private TranslationContext<JCMemberReference> makeReferenceContext(JCMemberReference tree) {
1138 return new ReferenceTranslationContext(tree);
1139 }
1141 private class Frame {
1142 final JCTree tree;
1143 List<Symbol> locals;
1145 public Frame(JCTree tree) {
1146 this.tree = tree;
1147 }
1149 void addLocal(Symbol sym) {
1150 if (locals == null) {
1151 locals = List.nil();
1152 }
1153 locals = locals.prepend(sym);
1154 }
1155 }
1157 /**
1158 * This class is used to store important information regarding translation of
1159 * lambda expression/method references (see subclasses).
1160 */
1161 private abstract class TranslationContext<T extends JCFunctionalExpression> {
1163 /** the underlying (untranslated) tree */
1164 T tree;
1166 /** points to the adjusted enclosing scope in which this lambda/mref expression occurs */
1167 Symbol owner;
1169 /** the depth of this lambda expression in the frame stack */
1170 int depth;
1172 /** the enclosing translation context (set for nested lambdas/mref) */
1173 TranslationContext<?> prev;
1175 TranslationContext(T tree) {
1176 this.tree = tree;
1177 this.owner = owner();
1178 this.depth = frameStack.size() - 1;
1179 this.prev = context();
1180 }
1181 }
1183 /**
1184 * This class retains all the useful information about a lambda expression;
1185 * the contents of this class are filled by the LambdaAnalyzer visitor,
1186 * and the used by the main translation routines in order to adjust references
1187 * to captured locals/members, etc.
1188 */
1189 private class LambdaTranslationContext extends TranslationContext<JCLambda> {
1191 /** variable in the enclosing context to which this lambda is assigned */
1192 Symbol self;
1194 /** map from original to translated lambda parameters */
1195 Map<Symbol, Symbol> lambdaParams = new LinkedHashMap<Symbol, Symbol>();
1197 /** map from original to translated lambda locals */
1198 Map<Symbol, Symbol> lambdaLocals = new LinkedHashMap<Symbol, Symbol>();
1200 /** map from variables in enclosing scope to translated synthetic parameters */
1201 Map<Symbol, Symbol> capturedLocals = new LinkedHashMap<Symbol, Symbol>();
1203 /** map from class symbols to translated synthetic parameters (for captured member access) */
1204 Map<Symbol, Symbol> capturedThis = new LinkedHashMap<Symbol, Symbol>();
1206 /** the synthetic symbol for the method hoisting the translated lambda */
1207 Symbol translatedSym;
1209 List<JCVariableDecl> syntheticParams;
1211 LambdaTranslationContext(JCLambda tree) {
1212 super(tree);
1213 Frame frame = frameStack.head;
1214 if (frame.tree.hasTag(VARDEF)) {
1215 self = ((JCVariableDecl)frame.tree).sym;
1216 }
1217 this.translatedSym = makeSyntheticMethod(0, lambdaName(), null, owner.enclClass());
1218 }
1220 /**
1221 * Translate a symbol of a given kind into something suitable for the
1222 * synthetic lambda body
1223 */
1224 Symbol translate(String name, Symbol sym, LambdaSymbolKind skind) {
1225 if (skind == CAPTURED_THIS) {
1226 return sym; // self represented
1227 } else {
1228 return makeSyntheticVar(FINAL, name, types.erasure(sym.type), translatedSym);
1229 }
1230 }
1232 void addSymbol(Symbol sym, LambdaSymbolKind skind) {
1233 Map<Symbol, Symbol> transMap = null;
1234 String preferredName;
1235 switch (skind) {
1236 case CAPTURED_THIS:
1237 transMap = capturedThis;
1238 preferredName = "encl$" + capturedThis.size();
1239 break;
1240 case CAPTURED_VAR:
1241 transMap = capturedLocals;
1242 preferredName = "cap$" + capturedLocals.size();
1243 break;
1244 case LOCAL_VAR:
1245 transMap = lambdaLocals;
1246 preferredName = sym.name.toString();
1247 break;
1248 case PARAM:
1249 transMap = lambdaParams;
1250 preferredName = sym.name.toString();
1251 break;
1252 default: throw new AssertionError();
1253 }
1254 if (!transMap.containsKey(sym)) {
1255 transMap.put(sym, translate(preferredName, sym, skind));
1256 }
1257 }
1259 Map<Symbol, Symbol> getSymbolMap(LambdaSymbolKind... skinds) {
1260 LinkedHashMap<Symbol, Symbol> translationMap = new LinkedHashMap<Symbol, Symbol>();
1261 for (LambdaSymbolKind skind : skinds) {
1262 switch (skind) {
1263 case CAPTURED_THIS:
1264 translationMap.putAll(capturedThis);
1265 break;
1266 case CAPTURED_VAR:
1267 translationMap.putAll(capturedLocals);
1268 break;
1269 case LOCAL_VAR:
1270 translationMap.putAll(lambdaLocals);
1271 break;
1272 case PARAM:
1273 translationMap.putAll(lambdaParams);
1274 break;
1275 default: throw new AssertionError();
1276 }
1277 }
1278 return translationMap;
1279 }
1281 /**
1282 * The translatedSym is not complete/accurate until the analysis is
1283 * finished. Once the analysis is finished, the translatedSym is
1284 * "completed" -- updated with type information, access modifiers,
1285 * and full parameter list.
1286 */
1287 void complete() {
1288 if (syntheticParams != null) {
1289 return;
1290 }
1291 boolean inInterface = translatedSym.owner.isInterface();
1292 boolean thisReferenced = !getSymbolMap(CAPTURED_THIS).isEmpty();
1293 boolean needInstance = thisReferenced || inInterface;
1295 // If instance access isn't needed, make it static
1296 // Interface methods much be public default methods, otherwise make it private
1297 translatedSym.flags_field = SYNTHETIC | (needInstance? 0 : STATIC) | (inInterface? PUBLIC | DEFAULT : PRIVATE);
1299 //compute synthetic params
1300 ListBuffer<JCVariableDecl> params = ListBuffer.lb();
1302 // The signature of the method is augmented with the following
1303 // synthetic parameters:
1304 //
1305 // 1) reference to enclosing contexts captured by the lambda expression
1306 // 2) enclosing locals captured by the lambda expression
1307 for (Symbol thisSym : getSymbolMap(CAPTURED_VAR, PARAM).values()) {
1308 params.append(make.VarDef((VarSymbol) thisSym, null));
1309 }
1311 syntheticParams = params.toList();
1313 //prepend synthetic args to translated lambda method signature
1314 translatedSym.type = (MethodType) types.createMethodTypeWithParameters(
1315 (MethodType) generatedLambdaSig(),
1316 TreeInfo.types(syntheticParams));
1317 }
1319 Type enclosingType() {
1320 return owner.isStatic() ?
1321 Type.noType :
1322 owner.enclClass().type;
1323 }
1325 Type generatedLambdaSig() {
1326 return types.erasure(tree.descriptorType);
1327 }
1328 }
1330 /**
1331 * This class retains all the useful information about a method reference;
1332 * the contents of this class are filled by the LambdaAnalyzer visitor,
1333 * and the used by the main translation routines in order to adjust method
1334 * references (i.e. in case a bridge is needed)
1335 */
1336 private class ReferenceTranslationContext extends TranslationContext<JCMemberReference> {
1338 final boolean isSuper;
1339 final Symbol bridgeSym;
1341 ReferenceTranslationContext(JCMemberReference tree) {
1342 super(tree);
1343 this.isSuper = tree.hasKind(ReferenceKind.SUPER);
1344 this.bridgeSym = needsBridge()
1345 ? makeSyntheticMethod(isSuper ? 0 : STATIC,
1346 lambdaName().append(names.fromString("$bridge")), null,
1347 owner.enclClass())
1348 : null;
1349 }
1351 /**
1352 * Get the opcode associated with this method reference
1353 */
1354 int referenceKind() {
1355 return LambdaToMethod.this.referenceKind(needsBridge() ? bridgeSym : tree.sym);
1356 }
1358 boolean needsVarArgsConversion() {
1359 return tree.varargsElement != null;
1360 }
1362 /**
1363 * @return Is this an array operation like clone()
1364 */
1365 boolean isArrayOp() {
1366 return tree.sym.owner == syms.arrayClass;
1367 }
1369 /**
1370 * Does this reference needs a bridge (i.e. var args need to be
1371 * expanded or "super" is used)
1372 */
1373 final boolean needsBridge() {
1374 return isSuper || needsVarArgsConversion() || isArrayOp();
1375 }
1377 Type generatedRefSig() {
1378 return types.erasure(tree.sym.type);
1379 }
1381 Type bridgedRefSig() {
1382 return types.erasure(types.findDescriptorSymbol(tree.targets.head).type);
1383 }
1384 }
1385 }
1386 // </editor-fold>
1388 enum LambdaSymbolKind {
1389 CAPTURED_VAR,
1390 CAPTURED_THIS,
1391 LOCAL_VAR,
1392 PARAM;
1393 }
1394 }