Mercurial > jdk8-mips64-public > langtools / file revision
src/share/classes/com/sun/tools/javac/tree/TreeMaker.java@12202e6ab78a
src/share/classes/com/sun/tools/javac/tree/TreeMaker.java
Tue, 05 Mar 2013 14:19:49 +0000
- author
- mcimadamore
- date
- Tue, 05 Mar 2013 14:19:49 +0000
- changeset 1615
- 12202e6ab78a
- parent 1521
- 71f35e4b93a5
- child 1755
- ddb4a2bfcd82
- permissions
- -rw-r--r--
8009129: Illegal access error when calling method reference
Summary: Javac generates method handle referencing non public type
Reviewed-by: jjg, rfield
1 /*
2 * Copyright (c) 1999, 2013, 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 */
26 package com.sun.tools.javac.tree;
28 import com.sun.tools.javac.code.*;
29 import com.sun.tools.javac.code.Symbol.*;
30 import com.sun.tools.javac.code.Type.*;
31 import com.sun.tools.javac.util.*;
32 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
34 import com.sun.tools.javac.tree.JCTree.*;
36 import static com.sun.tools.javac.code.Flags.*;
37 import static com.sun.tools.javac.code.Kinds.*;
38 import static com.sun.tools.javac.code.TypeTag.*;
40 /** Factory class for trees.
41 *
42 * <p><b>This is NOT part of any supported API.
43 * If you write code that depends on this, you do so at your own risk.
44 * This code and its internal interfaces are subject to change or
45 * deletion without notice.</b>
46 */
47 public class TreeMaker implements JCTree.Factory {
49 /** The context key for the tree factory. */
50 protected static final Context.Key<TreeMaker> treeMakerKey =
51 new Context.Key<TreeMaker>();
53 /** Get the TreeMaker instance. */
54 public static TreeMaker instance(Context context) {
55 TreeMaker instance = context.get(treeMakerKey);
56 if (instance == null)
57 instance = new TreeMaker(context);
58 return instance;
59 }
61 /** The position at which subsequent trees will be created.
62 */
63 public int pos = Position.NOPOS;
65 /** The toplevel tree to which created trees belong.
66 */
67 public JCCompilationUnit toplevel;
69 /** The current name table. */
70 Names names;
72 Types types;
74 /** The current symbol table. */
75 Symtab syms;
77 /** Create a tree maker with null toplevel and NOPOS as initial position.
78 */
79 protected TreeMaker(Context context) {
80 context.put(treeMakerKey, this);
81 this.pos = Position.NOPOS;
82 this.toplevel = null;
83 this.names = Names.instance(context);
84 this.syms = Symtab.instance(context);
85 this.types = Types.instance(context);
86 }
88 /** Create a tree maker with a given toplevel and FIRSTPOS as initial position.
89 */
90 protected TreeMaker(JCCompilationUnit toplevel, Names names, Types types, Symtab syms) {
91 this.pos = Position.FIRSTPOS;
92 this.toplevel = toplevel;
93 this.names = names;
94 this.types = types;
95 this.syms = syms;
96 }
98 /** Create a new tree maker for a given toplevel.
99 */
100 public TreeMaker forToplevel(JCCompilationUnit toplevel) {
101 return new TreeMaker(toplevel, names, types, syms);
102 }
104 /** Reassign current position.
105 */
106 public TreeMaker at(int pos) {
107 this.pos = pos;
108 return this;
109 }
111 /** Reassign current position.
112 */
113 public TreeMaker at(DiagnosticPosition pos) {
114 this.pos = (pos == null ? Position.NOPOS : pos.getStartPosition());
115 return this;
116 }
118 /**
119 * Create given tree node at current position.
120 * @param defs a list of ClassDef, Import, and Skip
121 */
122 public JCCompilationUnit TopLevel(List<JCAnnotation> packageAnnotations,
123 JCExpression pid,
124 List<JCTree> defs) {
125 Assert.checkNonNull(packageAnnotations);
126 for (JCTree node : defs)
127 Assert.check(node instanceof JCClassDecl
128 || node instanceof JCImport
129 || node instanceof JCSkip
130 || node instanceof JCErroneous
131 || (node instanceof JCExpressionStatement
132 && ((JCExpressionStatement)node).expr instanceof JCErroneous),
133 node.getClass().getSimpleName());
134 JCCompilationUnit tree = new JCCompilationUnit(packageAnnotations, pid, defs,
135 null, null, null, null);
136 tree.pos = pos;
137 return tree;
138 }
140 public JCImport Import(JCTree qualid, boolean importStatic) {
141 JCImport tree = new JCImport(qualid, importStatic);
142 tree.pos = pos;
143 return tree;
144 }
146 public JCClassDecl ClassDef(JCModifiers mods,
147 Name name,
148 List<JCTypeParameter> typarams,
149 JCExpression extending,
150 List<JCExpression> implementing,
151 List<JCTree> defs)
152 {
153 JCClassDecl tree = new JCClassDecl(mods,
154 name,
155 typarams,
156 extending,
157 implementing,
158 defs,
159 null);
160 tree.pos = pos;
161 return tree;
162 }
164 public JCMethodDecl MethodDef(JCModifiers mods,
165 Name name,
166 JCExpression restype,
167 List<JCTypeParameter> typarams,
168 List<JCVariableDecl> params,
169 List<JCExpression> thrown,
170 JCBlock body,
171 JCExpression defaultValue) {
172 return MethodDef(
173 mods, name, restype, typarams, null, params,
174 thrown, body, defaultValue);
175 }
177 public JCMethodDecl MethodDef(JCModifiers mods,
178 Name name,
179 JCExpression restype,
180 List<JCTypeParameter> typarams,
181 JCVariableDecl recvparam,
182 List<JCVariableDecl> params,
183 List<JCExpression> thrown,
184 JCBlock body,
185 JCExpression defaultValue)
186 {
187 JCMethodDecl tree = new JCMethodDecl(mods,
188 name,
189 restype,
190 typarams,
191 recvparam,
192 params,
193 thrown,
194 body,
195 defaultValue,
196 null);
197 tree.pos = pos;
198 return tree;
199 }
201 public JCVariableDecl VarDef(JCModifiers mods, Name name, JCExpression vartype, JCExpression init) {
202 JCVariableDecl tree = new JCVariableDecl(mods, name, vartype, init, null);
203 tree.pos = pos;
204 return tree;
205 }
207 public JCSkip Skip() {
208 JCSkip tree = new JCSkip();
209 tree.pos = pos;
210 return tree;
211 }
213 public JCBlock Block(long flags, List<JCStatement> stats) {
214 JCBlock tree = new JCBlock(flags, stats);
215 tree.pos = pos;
216 return tree;
217 }
219 public JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond) {
220 JCDoWhileLoop tree = new JCDoWhileLoop(body, cond);
221 tree.pos = pos;
222 return tree;
223 }
225 public JCWhileLoop WhileLoop(JCExpression cond, JCStatement body) {
226 JCWhileLoop tree = new JCWhileLoop(cond, body);
227 tree.pos = pos;
228 return tree;
229 }
231 public JCForLoop ForLoop(List<JCStatement> init,
232 JCExpression cond,
233 List<JCExpressionStatement> step,
234 JCStatement body)
235 {
236 JCForLoop tree = new JCForLoop(init, cond, step, body);
237 tree.pos = pos;
238 return tree;
239 }
241 public JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {
242 JCEnhancedForLoop tree = new JCEnhancedForLoop(var, expr, body);
243 tree.pos = pos;
244 return tree;
245 }
247 public JCLabeledStatement Labelled(Name label, JCStatement body) {
248 JCLabeledStatement tree = new JCLabeledStatement(label, body);
249 tree.pos = pos;
250 return tree;
251 }
253 public JCSwitch Switch(JCExpression selector, List<JCCase> cases) {
254 JCSwitch tree = new JCSwitch(selector, cases);
255 tree.pos = pos;
256 return tree;
257 }
259 public JCCase Case(JCExpression pat, List<JCStatement> stats) {
260 JCCase tree = new JCCase(pat, stats);
261 tree.pos = pos;
262 return tree;
263 }
265 public JCSynchronized Synchronized(JCExpression lock, JCBlock body) {
266 JCSynchronized tree = new JCSynchronized(lock, body);
267 tree.pos = pos;
268 return tree;
269 }
271 public JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer) {
272 return Try(List.<JCTree>nil(), body, catchers, finalizer);
273 }
275 public JCTry Try(List<JCTree> resources,
276 JCBlock body,
277 List<JCCatch> catchers,
278 JCBlock finalizer) {
279 JCTry tree = new JCTry(resources, body, catchers, finalizer);
280 tree.pos = pos;
281 return tree;
282 }
284 public JCCatch Catch(JCVariableDecl param, JCBlock body) {
285 JCCatch tree = new JCCatch(param, body);
286 tree.pos = pos;
287 return tree;
288 }
290 public JCConditional Conditional(JCExpression cond,
291 JCExpression thenpart,
292 JCExpression elsepart)
293 {
294 JCConditional tree = new JCConditional(cond, thenpart, elsepart);
295 tree.pos = pos;
296 return tree;
297 }
299 public JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart) {
300 JCIf tree = new JCIf(cond, thenpart, elsepart);
301 tree.pos = pos;
302 return tree;
303 }
305 public JCExpressionStatement Exec(JCExpression expr) {
306 JCExpressionStatement tree = new JCExpressionStatement(expr);
307 tree.pos = pos;
308 return tree;
309 }
311 public JCBreak Break(Name label) {
312 JCBreak tree = new JCBreak(label, null);
313 tree.pos = pos;
314 return tree;
315 }
317 public JCContinue Continue(Name label) {
318 JCContinue tree = new JCContinue(label, null);
319 tree.pos = pos;
320 return tree;
321 }
323 public JCReturn Return(JCExpression expr) {
324 JCReturn tree = new JCReturn(expr);
325 tree.pos = pos;
326 return tree;
327 }
329 public JCThrow Throw(JCTree expr) {
330 JCThrow tree = new JCThrow(expr);
331 tree.pos = pos;
332 return tree;
333 }
335 public JCAssert Assert(JCExpression cond, JCExpression detail) {
336 JCAssert tree = new JCAssert(cond, detail);
337 tree.pos = pos;
338 return tree;
339 }
341 public JCMethodInvocation Apply(List<JCExpression> typeargs,
342 JCExpression fn,
343 List<JCExpression> args)
344 {
345 JCMethodInvocation tree = new JCMethodInvocation(typeargs, fn, args);
346 tree.pos = pos;
347 return tree;
348 }
350 public JCNewClass NewClass(JCExpression encl,
351 List<JCExpression> typeargs,
352 JCExpression clazz,
353 List<JCExpression> args,
354 JCClassDecl def)
355 {
356 JCNewClass tree = new JCNewClass(encl, typeargs, clazz, args, def);
357 tree.pos = pos;
358 return tree;
359 }
361 public JCNewArray NewArray(JCExpression elemtype,
362 List<JCExpression> dims,
363 List<JCExpression> elems)
364 {
365 JCNewArray tree = new JCNewArray(elemtype, dims, elems);
366 tree.pos = pos;
367 return tree;
368 }
370 public JCLambda Lambda(List<JCVariableDecl> params,
371 JCTree body)
372 {
373 JCLambda tree = new JCLambda(params, body);
374 tree.pos = pos;
375 return tree;
376 }
378 public JCParens Parens(JCExpression expr) {
379 JCParens tree = new JCParens(expr);
380 tree.pos = pos;
381 return tree;
382 }
384 public JCAssign Assign(JCExpression lhs, JCExpression rhs) {
385 JCAssign tree = new JCAssign(lhs, rhs);
386 tree.pos = pos;
387 return tree;
388 }
390 public JCAssignOp Assignop(JCTree.Tag opcode, JCTree lhs, JCTree rhs) {
391 JCAssignOp tree = new JCAssignOp(opcode, lhs, rhs, null);
392 tree.pos = pos;
393 return tree;
394 }
396 public JCUnary Unary(JCTree.Tag opcode, JCExpression arg) {
397 JCUnary tree = new JCUnary(opcode, arg);
398 tree.pos = pos;
399 return tree;
400 }
402 public JCBinary Binary(JCTree.Tag opcode, JCExpression lhs, JCExpression rhs) {
403 JCBinary tree = new JCBinary(opcode, lhs, rhs, null);
404 tree.pos = pos;
405 return tree;
406 }
408 public JCTypeCast TypeCast(JCTree clazz, JCExpression expr) {
409 JCTypeCast tree = new JCTypeCast(clazz, expr);
410 tree.pos = pos;
411 return tree;
412 }
414 public JCInstanceOf TypeTest(JCExpression expr, JCTree clazz) {
415 JCInstanceOf tree = new JCInstanceOf(expr, clazz);
416 tree.pos = pos;
417 return tree;
418 }
420 public JCArrayAccess Indexed(JCExpression indexed, JCExpression index) {
421 JCArrayAccess tree = new JCArrayAccess(indexed, index);
422 tree.pos = pos;
423 return tree;
424 }
426 public JCFieldAccess Select(JCExpression selected, Name selector) {
427 JCFieldAccess tree = new JCFieldAccess(selected, selector, null);
428 tree.pos = pos;
429 return tree;
430 }
432 public JCMemberReference Reference(JCMemberReference.ReferenceMode mode, Name name,
433 JCExpression expr, List<JCExpression> typeargs) {
434 JCMemberReference tree = new JCMemberReference(mode, name, expr, typeargs);
435 tree.pos = pos;
436 return tree;
437 }
439 public JCIdent Ident(Name name) {
440 JCIdent tree = new JCIdent(name, null);
441 tree.pos = pos;
442 return tree;
443 }
445 public JCLiteral Literal(TypeTag tag, Object value) {
446 JCLiteral tree = new JCLiteral(tag, value);
447 tree.pos = pos;
448 return tree;
449 }
451 public JCPrimitiveTypeTree TypeIdent(TypeTag typetag) {
452 JCPrimitiveTypeTree tree = new JCPrimitiveTypeTree(typetag);
453 tree.pos = pos;
454 return tree;
455 }
457 public JCArrayTypeTree TypeArray(JCExpression elemtype) {
458 JCArrayTypeTree tree = new JCArrayTypeTree(elemtype);
459 tree.pos = pos;
460 return tree;
461 }
463 public JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments) {
464 JCTypeApply tree = new JCTypeApply(clazz, arguments);
465 tree.pos = pos;
466 return tree;
467 }
469 public JCTypeUnion TypeUnion(List<JCExpression> components) {
470 JCTypeUnion tree = new JCTypeUnion(components);
471 tree.pos = pos;
472 return tree;
473 }
475 public JCTypeIntersection TypeIntersection(List<JCExpression> components) {
476 JCTypeIntersection tree = new JCTypeIntersection(components);
477 tree.pos = pos;
478 return tree;
479 }
481 public JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds) {
482 return TypeParameter(name, bounds, List.<JCAnnotation>nil());
483 }
485 public JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds, List<JCAnnotation> annos) {
486 JCTypeParameter tree = new JCTypeParameter(name, bounds, annos);
487 tree.pos = pos;
488 return tree;
489 }
491 public JCWildcard Wildcard(TypeBoundKind kind, JCTree type) {
492 JCWildcard tree = new JCWildcard(kind, type);
493 tree.pos = pos;
494 return tree;
495 }
497 public TypeBoundKind TypeBoundKind(BoundKind kind) {
498 TypeBoundKind tree = new TypeBoundKind(kind);
499 tree.pos = pos;
500 return tree;
501 }
503 public JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args) {
504 JCAnnotation tree = new JCAnnotation(Tag.ANNOTATION, annotationType, args);
505 tree.pos = pos;
506 return tree;
507 }
509 public JCAnnotation TypeAnnotation(JCTree annotationType, List<JCExpression> args) {
510 JCAnnotation tree = new JCAnnotation(Tag.TYPE_ANNOTATION, annotationType, args);
511 tree.pos = pos;
512 return tree;
513 }
515 public JCModifiers Modifiers(long flags, List<JCAnnotation> annotations) {
516 JCModifiers tree = new JCModifiers(flags, annotations);
517 boolean noFlags = (flags & (Flags.ModifierFlags | Flags.ANNOTATION)) == 0;
518 tree.pos = (noFlags && annotations.isEmpty()) ? Position.NOPOS : pos;
519 return tree;
520 }
522 public JCModifiers Modifiers(long flags) {
523 return Modifiers(flags, List.<JCAnnotation>nil());
524 }
526 public JCAnnotatedType AnnotatedType(List<JCAnnotation> annotations, JCExpression underlyingType) {
527 JCAnnotatedType tree = new JCAnnotatedType(annotations, underlyingType);
528 tree.pos = pos;
529 return tree;
530 }
532 public JCErroneous Erroneous() {
533 return Erroneous(List.<JCTree>nil());
534 }
536 public JCErroneous Erroneous(List<? extends JCTree> errs) {
537 JCErroneous tree = new JCErroneous(errs);
538 tree.pos = pos;
539 return tree;
540 }
542 public LetExpr LetExpr(List<JCVariableDecl> defs, JCTree expr) {
543 LetExpr tree = new LetExpr(defs, expr);
544 tree.pos = pos;
545 return tree;
546 }
548 /* ***************************************************************************
549 * Derived building blocks.
550 ****************************************************************************/
552 public JCClassDecl AnonymousClassDef(JCModifiers mods,
553 List<JCTree> defs)
554 {
555 return ClassDef(mods,
556 names.empty,
557 List.<JCTypeParameter>nil(),
558 null,
559 List.<JCExpression>nil(),
560 defs);
561 }
563 public LetExpr LetExpr(JCVariableDecl def, JCTree expr) {
564 LetExpr tree = new LetExpr(List.of(def), expr);
565 tree.pos = pos;
566 return tree;
567 }
569 /** Create an identifier from a symbol.
570 */
571 public JCIdent Ident(Symbol sym) {
572 return (JCIdent)new JCIdent((sym.name != names.empty)
573 ? sym.name
574 : sym.flatName(), sym)
575 .setPos(pos)
576 .setType(sym.type);
577 }
579 /** Create a selection node from a qualifier tree and a symbol.
580 * @param base The qualifier tree.
581 */
582 public JCExpression Select(JCExpression base, Symbol sym) {
583 return new JCFieldAccess(base, sym.name, sym).setPos(pos).setType(sym.type);
584 }
586 /** Create a qualified identifier from a symbol, adding enough qualifications
587 * to make the reference unique.
588 */
589 public JCExpression QualIdent(Symbol sym) {
590 return isUnqualifiable(sym)
591 ? Ident(sym)
592 : Select(QualIdent(sym.owner), sym);
593 }
595 /** Create an identifier that refers to the variable declared in given variable
596 * declaration.
597 */
598 public JCExpression Ident(JCVariableDecl param) {
599 return Ident(param.sym);
600 }
602 /** Create a list of identifiers referring to the variables declared
603 * in given list of variable declarations.
604 */
605 public List<JCExpression> Idents(List<JCVariableDecl> params) {
606 ListBuffer<JCExpression> ids = new ListBuffer<JCExpression>();
607 for (List<JCVariableDecl> l = params; l.nonEmpty(); l = l.tail)
608 ids.append(Ident(l.head));
609 return ids.toList();
610 }
612 /** Create a tree representing `this', given its type.
613 */
614 public JCExpression This(Type t) {
615 return Ident(new VarSymbol(FINAL, names._this, t, t.tsym));
616 }
618 /** Create a tree representing a class literal.
619 */
620 public JCExpression ClassLiteral(ClassSymbol clazz) {
621 return ClassLiteral(clazz.type);
622 }
624 /** Create a tree representing a class literal.
625 */
626 public JCExpression ClassLiteral(Type t) {
627 VarSymbol lit = new VarSymbol(STATIC | PUBLIC | FINAL,
628 names._class,
629 t,
630 t.tsym);
631 return Select(Type(t), lit);
632 }
634 /** Create a tree representing `super', given its type and owner.
635 */
636 public JCIdent Super(Type t, TypeSymbol owner) {
637 return Ident(new VarSymbol(FINAL, names._super, t, owner));
638 }
640 /**
641 * Create a method invocation from a method tree and a list of
642 * argument trees.
643 */
644 public JCMethodInvocation App(JCExpression meth, List<JCExpression> args) {
645 return Apply(null, meth, args).setType(meth.type.getReturnType());
646 }
648 /**
649 * Create a no-arg method invocation from a method tree
650 */
651 public JCMethodInvocation App(JCExpression meth) {
652 return Apply(null, meth, List.<JCExpression>nil()).setType(meth.type.getReturnType());
653 }
655 /** Create a method invocation from a method tree and a list of argument trees.
656 */
657 public JCExpression Create(Symbol ctor, List<JCExpression> args) {
658 Type t = ctor.owner.erasure(types);
659 JCNewClass newclass = NewClass(null, null, Type(t), args, null);
660 newclass.constructor = ctor;
661 newclass.setType(t);
662 return newclass;
663 }
665 /** Create a tree representing given type.
666 */
667 public JCExpression Type(Type t) {
668 if (t == null) return null;
669 JCExpression tp;
670 switch (t.getTag()) {
671 case BYTE: case CHAR: case SHORT: case INT: case LONG: case FLOAT:
672 case DOUBLE: case BOOLEAN: case VOID:
673 tp = TypeIdent(t.getTag());
674 break;
675 case TYPEVAR:
676 tp = Ident(t.tsym);
677 break;
678 case WILDCARD: {
679 WildcardType a = ((WildcardType) t);
680 tp = Wildcard(TypeBoundKind(a.kind), Type(a.type));
681 break;
682 }
683 case CLASS:
684 Type outer = t.getEnclosingType();
685 JCExpression clazz = outer.hasTag(CLASS) && t.tsym.owner.kind == TYP
686 ? Select(Type(outer), t.tsym)
687 : QualIdent(t.tsym);
688 tp = t.getTypeArguments().isEmpty()
689 ? clazz
690 : TypeApply(clazz, Types(t.getTypeArguments()));
691 break;
692 case ARRAY:
693 tp = TypeArray(Type(types.elemtype(t)));
694 break;
695 case ERROR:
696 tp = TypeIdent(ERROR);
697 break;
698 default:
699 throw new AssertionError("unexpected type: " + t);
700 }
701 return tp.setType(t);
702 }
704 /** Create a list of trees representing given list of types.
705 */
706 public List<JCExpression> Types(List<Type> ts) {
707 ListBuffer<JCExpression> lb = new ListBuffer<JCExpression>();
708 for (List<Type> l = ts; l.nonEmpty(); l = l.tail)
709 lb.append(Type(l.head));
710 return lb.toList();
711 }
713 /** Create a variable definition from a variable symbol and an initializer
714 * expression.
715 */
716 public JCVariableDecl VarDef(VarSymbol v, JCExpression init) {
717 return (JCVariableDecl)
718 new JCVariableDecl(
719 Modifiers(v.flags(), Annotations(v.getRawAttributes())),
720 v.name,
721 Type(v.type),
722 init,
723 v).setPos(pos).setType(v.type);
724 }
726 /** Create annotation trees from annotations.
727 */
728 public List<JCAnnotation> Annotations(List<Attribute.Compound> attributes) {
729 if (attributes == null) return List.nil();
730 ListBuffer<JCAnnotation> result = new ListBuffer<JCAnnotation>();
731 for (List<Attribute.Compound> i = attributes; i.nonEmpty(); i=i.tail) {
732 Attribute a = i.head;
733 result.append(Annotation(a));
734 }
735 return result.toList();
736 }
738 public JCLiteral Literal(Object value) {
739 JCLiteral result = null;
740 if (value instanceof String) {
741 result = Literal(CLASS, value).
742 setType(syms.stringType.constType(value));
743 } else if (value instanceof Integer) {
744 result = Literal(INT, value).
745 setType(syms.intType.constType(value));
746 } else if (value instanceof Long) {
747 result = Literal(LONG, value).
748 setType(syms.longType.constType(value));
749 } else if (value instanceof Byte) {
750 result = Literal(BYTE, value).
751 setType(syms.byteType.constType(value));
752 } else if (value instanceof Character) {
753 int v = (int) (((Character) value).toString().charAt(0));
754 result = Literal(CHAR, value).
755 setType(syms.charType.constType(v));
756 } else if (value instanceof Double) {
757 result = Literal(DOUBLE, value).
758 setType(syms.doubleType.constType(value));
759 } else if (value instanceof Float) {
760 result = Literal(FLOAT, value).
761 setType(syms.floatType.constType(value));
762 } else if (value instanceof Short) {
763 result = Literal(SHORT, value).
764 setType(syms.shortType.constType(value));
765 } else if (value instanceof Boolean) {
766 int v = ((Boolean) value) ? 1 : 0;
767 result = Literal(BOOLEAN, v).
768 setType(syms.booleanType.constType(v));
769 } else {
770 throw new AssertionError(value);
771 }
772 return result;
773 }
775 class AnnotationBuilder implements Attribute.Visitor {
776 JCExpression result = null;
777 public void visitConstant(Attribute.Constant v) {
778 result = Literal(v.value);
779 }
780 public void visitClass(Attribute.Class clazz) {
781 result = ClassLiteral(clazz.classType).setType(syms.classType);
782 }
783 public void visitEnum(Attribute.Enum e) {
784 result = QualIdent(e.value);
785 }
786 public void visitError(Attribute.Error e) {
787 result = Erroneous();
788 }
789 public void visitCompound(Attribute.Compound compound) {
790 if (compound instanceof Attribute.TypeCompound) {
791 result = visitTypeCompoundInternal((Attribute.TypeCompound) compound);
792 } else {
793 result = visitCompoundInternal(compound);
794 }
795 }
796 public JCAnnotation visitCompoundInternal(Attribute.Compound compound) {
797 ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();
798 for (List<Pair<Symbol.MethodSymbol,Attribute>> values = compound.values; values.nonEmpty(); values=values.tail) {
799 Pair<MethodSymbol,Attribute> pair = values.head;
800 JCExpression valueTree = translate(pair.snd);
801 args.append(Assign(Ident(pair.fst), valueTree).setType(valueTree.type));
802 }
803 return Annotation(Type(compound.type), args.toList());
804 }
805 public JCAnnotation visitTypeCompoundInternal(Attribute.TypeCompound compound) {
806 ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();
807 for (List<Pair<Symbol.MethodSymbol,Attribute>> values = compound.values; values.nonEmpty(); values=values.tail) {
808 Pair<MethodSymbol,Attribute> pair = values.head;
809 JCExpression valueTree = translate(pair.snd);
810 args.append(Assign(Ident(pair.fst), valueTree).setType(valueTree.type));
811 }
812 return TypeAnnotation(Type(compound.type), args.toList());
813 }
814 public void visitArray(Attribute.Array array) {
815 ListBuffer<JCExpression> elems = new ListBuffer<JCExpression>();
816 for (int i = 0; i < array.values.length; i++)
817 elems.append(translate(array.values[i]));
818 result = NewArray(null, List.<JCExpression>nil(), elems.toList()).setType(array.type);
819 }
820 JCExpression translate(Attribute a) {
821 a.accept(this);
822 return result;
823 }
824 JCAnnotation translate(Attribute.Compound a) {
825 return visitCompoundInternal(a);
826 }
827 JCAnnotation translate(Attribute.TypeCompound a) {
828 return visitTypeCompoundInternal(a);
829 }
830 }
832 AnnotationBuilder annotationBuilder = new AnnotationBuilder();
834 /** Create an annotation tree from an attribute.
835 */
836 public JCAnnotation Annotation(Attribute a) {
837 return annotationBuilder.translate((Attribute.Compound)a);
838 }
840 public JCAnnotation TypeAnnotation(Attribute a) {
841 return annotationBuilder.translate((Attribute.TypeCompound) a);
842 }
844 /** Create a method definition from a method symbol and a method body.
845 */
846 public JCMethodDecl MethodDef(MethodSymbol m, JCBlock body) {
847 return MethodDef(m, m.type, body);
848 }
850 /** Create a method definition from a method symbol, method type
851 * and a method body.
852 */
853 public JCMethodDecl MethodDef(MethodSymbol m, Type mtype, JCBlock body) {
854 return (JCMethodDecl)
855 new JCMethodDecl(
856 Modifiers(m.flags(), Annotations(m.getRawAttributes())),
857 m.name,
858 Type(mtype.getReturnType()),
859 TypeParams(mtype.getTypeArguments()),
860 null, // receiver type
861 Params(mtype.getParameterTypes(), m),
862 Types(mtype.getThrownTypes()),
863 body,
864 null,
865 m).setPos(pos).setType(mtype);
866 }
868 /** Create a type parameter tree from its name and type.
869 */
870 public JCTypeParameter TypeParam(Name name, TypeVar tvar) {
871 return (JCTypeParameter)
872 TypeParameter(name, Types(types.getBounds(tvar))).setPos(pos).setType(tvar);
873 }
875 /** Create a list of type parameter trees from a list of type variables.
876 */
877 public List<JCTypeParameter> TypeParams(List<Type> typarams) {
878 ListBuffer<JCTypeParameter> tparams = new ListBuffer<JCTypeParameter>();
879 for (List<Type> l = typarams; l.nonEmpty(); l = l.tail)
880 tparams.append(TypeParam(l.head.tsym.name, (TypeVar)l.head));
881 return tparams.toList();
882 }
884 /** Create a value parameter tree from its name, type, and owner.
885 */
886 public JCVariableDecl Param(Name name, Type argtype, Symbol owner) {
887 return VarDef(new VarSymbol(0, name, argtype, owner), null);
888 }
890 /** Create a a list of value parameter trees x0, ..., xn from a list of
891 * their types and an their owner.
892 */
893 public List<JCVariableDecl> Params(List<Type> argtypes, Symbol owner) {
894 ListBuffer<JCVariableDecl> params = new ListBuffer<JCVariableDecl>();
895 MethodSymbol mth = (owner.kind == MTH) ? ((MethodSymbol)owner) : null;
896 if (mth != null && mth.params != null && argtypes.length() == mth.params.length()) {
897 for (VarSymbol param : ((MethodSymbol)owner).params)
898 params.append(VarDef(param, null));
899 } else {
900 int i = 0;
901 for (List<Type> l = argtypes; l.nonEmpty(); l = l.tail)
902 params.append(Param(paramName(i++), l.head, owner));
903 }
904 return params.toList();
905 }
907 /** Wrap a method invocation in an expression statement or return statement,
908 * depending on whether the method invocation expression's type is void.
909 */
910 public JCStatement Call(JCExpression apply) {
911 return apply.type.hasTag(VOID) ? Exec(apply) : Return(apply);
912 }
914 /** Construct an assignment from a variable symbol and a right hand side.
915 */
916 public JCStatement Assignment(Symbol v, JCExpression rhs) {
917 return Exec(Assign(Ident(v), rhs).setType(v.type));
918 }
920 /** Construct an index expression from a variable and an expression.
921 */
922 public JCArrayAccess Indexed(Symbol v, JCExpression index) {
923 JCArrayAccess tree = new JCArrayAccess(QualIdent(v), index);
924 tree.type = ((ArrayType)v.type).elemtype;
925 return tree;
926 }
928 /** Make an attributed type cast expression.
929 */
930 public JCTypeCast TypeCast(Type type, JCExpression expr) {
931 return (JCTypeCast)TypeCast(Type(type), expr).setType(type);
932 }
934 /* ***************************************************************************
935 * Helper methods.
936 ****************************************************************************/
938 /** Can given symbol be referred to in unqualified form?
939 */
940 boolean isUnqualifiable(Symbol sym) {
941 if (sym.name == names.empty ||
942 sym.owner == null ||
943 sym.owner.kind == MTH || sym.owner.kind == VAR) {
944 return true;
945 } else if (sym.kind == TYP && toplevel != null) {
946 Scope.Entry e;
947 e = toplevel.namedImportScope.lookup(sym.name);
948 if (e.scope != null) {
949 return
950 e.sym == sym &&
951 e.next().scope == null;
952 }
953 e = toplevel.packge.members().lookup(sym.name);
954 if (e.scope != null) {
955 return
956 e.sym == sym &&
957 e.next().scope == null;
958 }
959 e = toplevel.starImportScope.lookup(sym.name);
960 if (e.scope != null) {
961 return
962 e.sym == sym &&
963 e.next().scope == null;
964 }
965 }
966 return false;
967 }
969 /** The name of synthetic parameter number `i'.
970 */
971 public Name paramName(int i) { return names.fromString("x" + i); }
973 /** The name of synthetic type parameter number `i'.
974 */
975 public Name typaramName(int i) { return names.fromString("A" + i); }
976 }
