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