duke@1: /*
jjg@815: * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
duke@1: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1: *
duke@1: * This code is free software; you can redistribute it and/or modify it
duke@1: * under the terms of the GNU General Public License version 2 only, as
ohair@554: * published by the Free Software Foundation. Oracle designates this
duke@1: * particular file as subject to the "Classpath" exception as provided
ohair@554: * by Oracle in the LICENSE file that accompanied this code.
duke@1: *
duke@1: * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@1: * version 2 for more details (a copy is included in the LICENSE file that
duke@1: * accompanied this code).
duke@1: *
duke@1: * You should have received a copy of the GNU General Public License version
duke@1: * 2 along with this work; if not, write to the Free Software Foundation,
duke@1: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1: *
ohair@554: * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
ohair@554: * or visit www.oracle.com if you need additional information or have any
ohair@554: * questions.
duke@1: */
duke@1:
duke@1: package com.sun.tools.javac.tree;
duke@1:
duke@1: import com.sun.tools.javac.code.*;
duke@1: import com.sun.tools.javac.code.Symbol.*;
duke@1: import com.sun.tools.javac.code.Type.*;
duke@1: import com.sun.tools.javac.util.*;
duke@1: import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
duke@1:
duke@1: import com.sun.tools.javac.tree.JCTree.*;
duke@1:
duke@1: import static com.sun.tools.javac.code.Flags.*;
duke@1: import static com.sun.tools.javac.code.Kinds.*;
duke@1: import static com.sun.tools.javac.code.TypeTags.*;
duke@1:
duke@1: /** Factory class for trees.
duke@1: *
jjg@581: *
This is NOT part of any supported API.
jjg@581: * If you write code that depends on this, you do so at your own risk.
duke@1: * This code and its internal interfaces are subject to change or
duke@1: * deletion without notice.
duke@1: */
duke@1: public class TreeMaker implements JCTree.Factory {
duke@1:
duke@1: /** The context key for the tree factory. */
duke@1: protected static final Context.Key treeMakerKey =
duke@1: new Context.Key();
duke@1:
duke@1: /** Get the TreeMaker instance. */
duke@1: public static TreeMaker instance(Context context) {
duke@1: TreeMaker instance = context.get(treeMakerKey);
duke@1: if (instance == null)
duke@1: instance = new TreeMaker(context);
duke@1: return instance;
duke@1: }
duke@1:
duke@1: /** The position at which subsequent trees will be created.
duke@1: */
duke@1: public int pos = Position.NOPOS;
duke@1:
duke@1: /** The toplevel tree to which created trees belong.
duke@1: */
duke@1: public JCCompilationUnit toplevel;
duke@1:
duke@1: /** The current name table. */
jjg@113: Names names;
duke@1:
duke@1: Types types;
duke@1:
duke@1: /** The current symbol table. */
duke@1: Symtab syms;
duke@1:
duke@1: /** Create a tree maker with null toplevel and NOPOS as initial position.
duke@1: */
duke@1: protected TreeMaker(Context context) {
duke@1: context.put(treeMakerKey, this);
duke@1: this.pos = Position.NOPOS;
duke@1: this.toplevel = null;
jjg@113: this.names = Names.instance(context);
duke@1: this.syms = Symtab.instance(context);
duke@1: this.types = Types.instance(context);
duke@1: }
duke@1:
duke@1: /** Create a tree maker with a given toplevel and FIRSTPOS as initial position.
duke@1: */
jjg@113: TreeMaker(JCCompilationUnit toplevel, Names names, Types types, Symtab syms) {
duke@1: this.pos = Position.FIRSTPOS;
duke@1: this.toplevel = toplevel;
duke@1: this.names = names;
duke@1: this.types = types;
duke@1: this.syms = syms;
duke@1: }
duke@1:
duke@1: /** Create a new tree maker for a given toplevel.
duke@1: */
duke@1: public TreeMaker forToplevel(JCCompilationUnit toplevel) {
duke@1: return new TreeMaker(toplevel, names, types, syms);
duke@1: }
duke@1:
duke@1: /** Reassign current position.
duke@1: */
duke@1: public TreeMaker at(int pos) {
duke@1: this.pos = pos;
duke@1: return this;
duke@1: }
duke@1:
duke@1: /** Reassign current position.
duke@1: */
duke@1: public TreeMaker at(DiagnosticPosition pos) {
duke@1: this.pos = (pos == null ? Position.NOPOS : pos.getStartPosition());
duke@1: return this;
duke@1: }
duke@1:
duke@1: /**
duke@1: * Create given tree node at current position.
duke@1: * @param defs a list of ClassDef, Import, and Skip
duke@1: */
duke@1: public JCCompilationUnit TopLevel(List packageAnnotations,
duke@1: JCExpression pid,
duke@1: List defs) {
jjg@816: Assert.checkNonNull(packageAnnotations);
duke@1: for (JCTree node : defs)
jjg@816: Assert.check(node instanceof JCClassDecl
duke@1: || node instanceof JCImport
duke@1: || node instanceof JCSkip
duke@1: || node instanceof JCErroneous
duke@1: || (node instanceof JCExpressionStatement
jjg@816: && ((JCExpressionStatement)node).expr instanceof JCErroneous),
jjg@816: node.getClass().getSimpleName());
duke@1: JCCompilationUnit tree = new JCCompilationUnit(packageAnnotations, pid, defs,
duke@1: null, null, null, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCImport Import(JCTree qualid, boolean importStatic) {
duke@1: JCImport tree = new JCImport(qualid, importStatic);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCClassDecl ClassDef(JCModifiers mods,
duke@1: Name name,
duke@1: List typarams,
jjg@904: JCExpression extending,
duke@1: List implementing,
duke@1: List defs)
duke@1: {
duke@1: JCClassDecl tree = new JCClassDecl(mods,
duke@1: name,
duke@1: typarams,
duke@1: extending,
duke@1: implementing,
duke@1: defs,
duke@1: null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCMethodDecl MethodDef(JCModifiers mods,
duke@1: Name name,
duke@1: JCExpression restype,
duke@1: List typarams,
duke@1: List params,
duke@1: List thrown,
duke@1: JCBlock body,
jjg@308: JCExpression defaultValue) {
duke@1: JCMethodDecl tree = new JCMethodDecl(mods,
duke@1: name,
duke@1: restype,
duke@1: typarams,
duke@1: params,
duke@1: thrown,
duke@1: body,
duke@1: defaultValue,
duke@1: null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCVariableDecl VarDef(JCModifiers mods, Name name, JCExpression vartype, JCExpression init) {
duke@1: JCVariableDecl tree = new JCVariableDecl(mods, name, vartype, init, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCSkip Skip() {
duke@1: JCSkip tree = new JCSkip();
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCBlock Block(long flags, List stats) {
duke@1: JCBlock tree = new JCBlock(flags, stats);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond) {
duke@1: JCDoWhileLoop tree = new JCDoWhileLoop(body, cond);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCWhileLoop WhileLoop(JCExpression cond, JCStatement body) {
duke@1: JCWhileLoop tree = new JCWhileLoop(cond, body);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCForLoop ForLoop(List init,
duke@1: JCExpression cond,
duke@1: List step,
duke@1: JCStatement body)
duke@1: {
duke@1: JCForLoop tree = new JCForLoop(init, cond, step, body);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {
duke@1: JCEnhancedForLoop tree = new JCEnhancedForLoop(var, expr, body);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCLabeledStatement Labelled(Name label, JCStatement body) {
duke@1: JCLabeledStatement tree = new JCLabeledStatement(label, body);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCSwitch Switch(JCExpression selector, List cases) {
duke@1: JCSwitch tree = new JCSwitch(selector, cases);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCCase Case(JCExpression pat, List stats) {
duke@1: JCCase tree = new JCCase(pat, stats);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCSynchronized Synchronized(JCExpression lock, JCBlock body) {
duke@1: JCSynchronized tree = new JCSynchronized(lock, body);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCTry Try(JCBlock body, List catchers, JCBlock finalizer) {
darcy@609: return Try(List.nil(), body, catchers, finalizer);
darcy@609: }
darcy@609:
darcy@609: public JCTry Try(List resources,
darcy@609: JCBlock body,
darcy@609: List catchers,
darcy@609: JCBlock finalizer) {
darcy@609: JCTry tree = new JCTry(resources, body, catchers, finalizer);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCCatch Catch(JCVariableDecl param, JCBlock body) {
duke@1: JCCatch tree = new JCCatch(param, body);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCConditional Conditional(JCExpression cond,
duke@1: JCExpression thenpart,
duke@1: JCExpression elsepart)
duke@1: {
duke@1: JCConditional tree = new JCConditional(cond, thenpart, elsepart);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart) {
duke@1: JCIf tree = new JCIf(cond, thenpart, elsepart);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCExpressionStatement Exec(JCExpression expr) {
duke@1: JCExpressionStatement tree = new JCExpressionStatement(expr);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCBreak Break(Name label) {
duke@1: JCBreak tree = new JCBreak(label, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCContinue Continue(Name label) {
duke@1: JCContinue tree = new JCContinue(label, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCReturn Return(JCExpression expr) {
duke@1: JCReturn tree = new JCReturn(expr);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCThrow Throw(JCTree expr) {
duke@1: JCThrow tree = new JCThrow(expr);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCAssert Assert(JCExpression cond, JCExpression detail) {
duke@1: JCAssert tree = new JCAssert(cond, detail);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCMethodInvocation Apply(List typeargs,
duke@1: JCExpression fn,
duke@1: List args)
duke@1: {
duke@1: JCMethodInvocation tree = new JCMethodInvocation(typeargs, fn, args);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCNewClass NewClass(JCExpression encl,
duke@1: List typeargs,
duke@1: JCExpression clazz,
duke@1: List args,
duke@1: JCClassDecl def)
duke@1: {
duke@1: JCNewClass tree = new JCNewClass(encl, typeargs, clazz, args, def);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCNewArray NewArray(JCExpression elemtype,
duke@1: List dims,
duke@1: List elems)
duke@1: {
duke@1: JCNewArray tree = new JCNewArray(elemtype, dims, elems);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
mcimadamore@1142: public JCLambda Lambda(List params,
mcimadamore@1142: JCTree body)
mcimadamore@1142: {
mcimadamore@1142: JCLambda tree = new JCLambda(params, body);
mcimadamore@1142: tree.pos = pos;
mcimadamore@1142: return tree;
mcimadamore@1142: }
mcimadamore@1142:
duke@1: public JCParens Parens(JCExpression expr) {
duke@1: JCParens tree = new JCParens(expr);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCAssign Assign(JCExpression lhs, JCExpression rhs) {
duke@1: JCAssign tree = new JCAssign(lhs, rhs);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
jjg@1127: public JCAssignOp Assignop(JCTree.Tag opcode, JCTree lhs, JCTree rhs) {
duke@1: JCAssignOp tree = new JCAssignOp(opcode, lhs, rhs, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
jjg@1127: public JCUnary Unary(JCTree.Tag opcode, JCExpression arg) {
duke@1: JCUnary tree = new JCUnary(opcode, arg);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
jjg@1127: public JCBinary Binary(JCTree.Tag opcode, JCExpression lhs, JCExpression rhs) {
duke@1: JCBinary tree = new JCBinary(opcode, lhs, rhs, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCTypeCast TypeCast(JCTree clazz, JCExpression expr) {
duke@1: JCTypeCast tree = new JCTypeCast(clazz, expr);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCInstanceOf TypeTest(JCExpression expr, JCTree clazz) {
duke@1: JCInstanceOf tree = new JCInstanceOf(expr, clazz);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCArrayAccess Indexed(JCExpression indexed, JCExpression index) {
duke@1: JCArrayAccess tree = new JCArrayAccess(indexed, index);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCFieldAccess Select(JCExpression selected, Name selector) {
duke@1: JCFieldAccess tree = new JCFieldAccess(selected, selector, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
mcimadamore@1143: public JCMemberReference Reference(JCMemberReference.ReferenceMode mode, Name name,
mcimadamore@1143: JCExpression expr, List typeargs) {
mcimadamore@1143: JCMemberReference tree = new JCMemberReference(mode, name, expr, typeargs);
mcimadamore@1143: tree.pos = pos;
mcimadamore@1143: return tree;
mcimadamore@1143: }
mcimadamore@1143:
duke@1: public JCIdent Ident(Name name) {
duke@1: JCIdent tree = new JCIdent(name, null);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCLiteral Literal(int tag, Object value) {
duke@1: JCLiteral tree = new JCLiteral(tag, value);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCPrimitiveTypeTree TypeIdent(int typetag) {
duke@1: JCPrimitiveTypeTree tree = new JCPrimitiveTypeTree(typetag);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCArrayTypeTree TypeArray(JCExpression elemtype) {
duke@1: JCArrayTypeTree tree = new JCArrayTypeTree(elemtype);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCTypeApply TypeApply(JCExpression clazz, List arguments) {
duke@1: JCTypeApply tree = new JCTypeApply(clazz, arguments);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
darcy@969: public JCTypeUnion TypeUnion(List components) {
darcy@969: JCTypeUnion tree = new JCTypeUnion(components);
mcimadamore@550: tree.pos = pos;
mcimadamore@550: return tree;
mcimadamore@550: }
mcimadamore@550:
duke@1: public JCTypeParameter TypeParameter(Name name, List bounds) {
jjg@815: JCTypeParameter tree = new JCTypeParameter(name, bounds);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCWildcard Wildcard(TypeBoundKind kind, JCTree type) {
duke@1: JCWildcard tree = new JCWildcard(kind, type);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public TypeBoundKind TypeBoundKind(BoundKind kind) {
duke@1: TypeBoundKind tree = new TypeBoundKind(kind);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCAnnotation Annotation(JCTree annotationType, List args) {
duke@1: JCAnnotation tree = new JCAnnotation(annotationType, args);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCModifiers Modifiers(long flags, List annotations) {
duke@1: JCModifiers tree = new JCModifiers(flags, annotations);
jjg@613: boolean noFlags = (flags & (Flags.ModifierFlags | Flags.ANNOTATION)) == 0;
duke@1: tree.pos = (noFlags && annotations.isEmpty()) ? Position.NOPOS : pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public JCModifiers Modifiers(long flags) {
duke@1: return Modifiers(flags, List.nil());
duke@1: }
duke@1:
duke@1: public JCErroneous Erroneous() {
duke@1: return Erroneous(List.nil());
duke@1: }
duke@1:
duke@1: public JCErroneous Erroneous(List extends JCTree> errs) {
duke@1: JCErroneous tree = new JCErroneous(errs);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: public LetExpr LetExpr(List defs, JCTree expr) {
duke@1: LetExpr tree = new LetExpr(defs, expr);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: /* ***************************************************************************
duke@1: * Derived building blocks.
duke@1: ****************************************************************************/
duke@1:
duke@1: public JCClassDecl AnonymousClassDef(JCModifiers mods,
duke@1: List defs)
duke@1: {
duke@1: return ClassDef(mods,
duke@1: names.empty,
duke@1: List.nil(),
duke@1: null,
duke@1: List.nil(),
duke@1: defs);
duke@1: }
duke@1:
duke@1: public LetExpr LetExpr(JCVariableDecl def, JCTree expr) {
duke@1: LetExpr tree = new LetExpr(List.of(def), expr);
duke@1: tree.pos = pos;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: /** Create an identifier from a symbol.
duke@1: */
duke@1: public JCIdent Ident(Symbol sym) {
duke@1: return (JCIdent)new JCIdent((sym.name != names.empty)
duke@1: ? sym.name
duke@1: : sym.flatName(), sym)
duke@1: .setPos(pos)
duke@1: .setType(sym.type);
duke@1: }
duke@1:
duke@1: /** Create a selection node from a qualifier tree and a symbol.
duke@1: * @param base The qualifier tree.
duke@1: */
duke@1: public JCExpression Select(JCExpression base, Symbol sym) {
duke@1: return new JCFieldAccess(base, sym.name, sym).setPos(pos).setType(sym.type);
duke@1: }
duke@1:
duke@1: /** Create a qualified identifier from a symbol, adding enough qualifications
duke@1: * to make the reference unique.
duke@1: */
duke@1: public JCExpression QualIdent(Symbol sym) {
duke@1: return isUnqualifiable(sym)
duke@1: ? Ident(sym)
duke@1: : Select(QualIdent(sym.owner), sym);
duke@1: }
duke@1:
duke@1: /** Create an identifier that refers to the variable declared in given variable
duke@1: * declaration.
duke@1: */
duke@1: public JCExpression Ident(JCVariableDecl param) {
duke@1: return Ident(param.sym);
duke@1: }
duke@1:
duke@1: /** Create a list of identifiers referring to the variables declared
duke@1: * in given list of variable declarations.
duke@1: */
duke@1: public List Idents(List params) {
duke@1: ListBuffer ids = new ListBuffer();
duke@1: for (List l = params; l.nonEmpty(); l = l.tail)
duke@1: ids.append(Ident(l.head));
duke@1: return ids.toList();
duke@1: }
duke@1:
duke@1: /** Create a tree representing `this', given its type.
duke@1: */
duke@1: public JCExpression This(Type t) {
duke@1: return Ident(new VarSymbol(FINAL, names._this, t, t.tsym));
duke@1: }
duke@1:
duke@1: /** Create a tree representing a class literal.
duke@1: */
duke@1: public JCExpression ClassLiteral(ClassSymbol clazz) {
duke@1: return ClassLiteral(clazz.type);
duke@1: }
duke@1:
duke@1: /** Create a tree representing a class literal.
duke@1: */
duke@1: public JCExpression ClassLiteral(Type t) {
duke@1: VarSymbol lit = new VarSymbol(STATIC | PUBLIC | FINAL,
duke@1: names._class,
duke@1: t,
duke@1: t.tsym);
duke@1: return Select(Type(t), lit);
duke@1: }
duke@1:
duke@1: /** Create a tree representing `super', given its type and owner.
duke@1: */
duke@1: public JCIdent Super(Type t, TypeSymbol owner) {
duke@1: return Ident(new VarSymbol(FINAL, names._super, t, owner));
duke@1: }
duke@1:
duke@1: /**
duke@1: * Create a method invocation from a method tree and a list of
duke@1: * argument trees.
duke@1: */
duke@1: public JCMethodInvocation App(JCExpression meth, List args) {
duke@1: return Apply(null, meth, args).setType(meth.type.getReturnType());
duke@1: }
duke@1:
duke@1: /**
duke@1: * Create a no-arg method invocation from a method tree
duke@1: */
duke@1: public JCMethodInvocation App(JCExpression meth) {
duke@1: return Apply(null, meth, List.nil()).setType(meth.type.getReturnType());
duke@1: }
duke@1:
duke@1: /** Create a method invocation from a method tree and a list of argument trees.
duke@1: */
duke@1: public JCExpression Create(Symbol ctor, List args) {
duke@1: Type t = ctor.owner.erasure(types);
duke@1: JCNewClass newclass = NewClass(null, null, Type(t), args, null);
duke@1: newclass.constructor = ctor;
duke@1: newclass.setType(t);
duke@1: return newclass;
duke@1: }
duke@1:
duke@1: /** Create a tree representing given type.
duke@1: */
duke@1: public JCExpression Type(Type t) {
duke@1: if (t == null) return null;
duke@1: JCExpression tp;
duke@1: switch (t.tag) {
duke@1: case BYTE: case CHAR: case SHORT: case INT: case LONG: case FLOAT:
duke@1: case DOUBLE: case BOOLEAN: case VOID:
duke@1: tp = TypeIdent(t.tag);
duke@1: break;
duke@1: case TYPEVAR:
duke@1: tp = Ident(t.tsym);
duke@1: break;
duke@1: case WILDCARD: {
duke@1: WildcardType a = ((WildcardType) t);
duke@1: tp = Wildcard(TypeBoundKind(a.kind), Type(a.type));
duke@1: break;
duke@1: }
duke@1: case CLASS:
duke@1: Type outer = t.getEnclosingType();
duke@1: JCExpression clazz = outer.tag == CLASS && t.tsym.owner.kind == TYP
duke@1: ? Select(Type(outer), t.tsym)
duke@1: : QualIdent(t.tsym);
duke@1: tp = t.getTypeArguments().isEmpty()
duke@1: ? clazz
duke@1: : TypeApply(clazz, Types(t.getTypeArguments()));
duke@1: break;
duke@1: case ARRAY:
duke@1: tp = TypeArray(Type(types.elemtype(t)));
duke@1: break;
duke@1: case ERROR:
duke@1: tp = TypeIdent(ERROR);
duke@1: break;
duke@1: default:
duke@1: throw new AssertionError("unexpected type: " + t);
duke@1: }
duke@1: return tp.setType(t);
duke@1: }
duke@1:
duke@1: /** Create a list of trees representing given list of types.
duke@1: */
duke@1: public List Types(List ts) {
jjg@816: ListBuffer lb = new ListBuffer();
duke@1: for (List l = ts; l.nonEmpty(); l = l.tail)
jjg@816: lb.append(Type(l.head));
jjg@816: return lb.toList();
duke@1: }
duke@1:
duke@1: /** Create a variable definition from a variable symbol and an initializer
duke@1: * expression.
duke@1: */
duke@1: public JCVariableDecl VarDef(VarSymbol v, JCExpression init) {
duke@1: return (JCVariableDecl)
duke@1: new JCVariableDecl(
duke@1: Modifiers(v.flags(), Annotations(v.getAnnotationMirrors())),
duke@1: v.name,
duke@1: Type(v.type),
duke@1: init,
duke@1: v).setPos(pos).setType(v.type);
duke@1: }
duke@1:
duke@1: /** Create annotation trees from annotations.
duke@1: */
duke@1: public List Annotations(List attributes) {
duke@1: if (attributes == null) return List.nil();
duke@1: ListBuffer result = new ListBuffer();
duke@1: for (List i = attributes; i.nonEmpty(); i=i.tail) {
duke@1: Attribute a = i.head;
duke@1: result.append(Annotation(a));
duke@1: }
duke@1: return result.toList();
duke@1: }
duke@1:
duke@1: public JCLiteral Literal(Object value) {
duke@1: JCLiteral result = null;
duke@1: if (value instanceof String) {
duke@1: result = Literal(CLASS, value).
duke@1: setType(syms.stringType.constType(value));
duke@1: } else if (value instanceof Integer) {
duke@1: result = Literal(INT, value).
duke@1: setType(syms.intType.constType(value));
duke@1: } else if (value instanceof Long) {
duke@1: result = Literal(LONG, value).
duke@1: setType(syms.longType.constType(value));
duke@1: } else if (value instanceof Byte) {
duke@1: result = Literal(BYTE, value).
duke@1: setType(syms.byteType.constType(value));
duke@1: } else if (value instanceof Character) {
jjg@788: int v = (int) (((Character) value).toString().charAt(0));
duke@1: result = Literal(CHAR, value).
jjg@788: setType(syms.charType.constType(v));
duke@1: } else if (value instanceof Double) {
duke@1: result = Literal(DOUBLE, value).
duke@1: setType(syms.doubleType.constType(value));
duke@1: } else if (value instanceof Float) {
duke@1: result = Literal(FLOAT, value).
duke@1: setType(syms.floatType.constType(value));
duke@1: } else if (value instanceof Short) {
duke@1: result = Literal(SHORT, value).
duke@1: setType(syms.shortType.constType(value));
jjg@788: } else if (value instanceof Boolean) {
jjg@788: int v = ((Boolean) value) ? 1 : 0;
jjg@788: result = Literal(BOOLEAN, v).
jjg@788: setType(syms.booleanType.constType(v));
duke@1: } else {
duke@1: throw new AssertionError(value);
duke@1: }
duke@1: return result;
duke@1: }
duke@1:
duke@1: class AnnotationBuilder implements Attribute.Visitor {
duke@1: JCExpression result = null;
duke@1: public void visitConstant(Attribute.Constant v) {
duke@1: result = Literal(v.value);
duke@1: }
duke@1: public void visitClass(Attribute.Class clazz) {
duke@1: result = ClassLiteral(clazz.type).setType(syms.classType);
duke@1: }
duke@1: public void visitEnum(Attribute.Enum e) {
duke@1: result = QualIdent(e.value);
duke@1: }
duke@1: public void visitError(Attribute.Error e) {
duke@1: result = Erroneous();
duke@1: }
duke@1: public void visitCompound(Attribute.Compound compound) {
duke@1: result = visitCompoundInternal(compound);
duke@1: }
duke@1: public JCAnnotation visitCompoundInternal(Attribute.Compound compound) {
duke@1: ListBuffer args = new ListBuffer();
duke@1: for (List> values = compound.values; values.nonEmpty(); values=values.tail) {
duke@1: Pair pair = values.head;
duke@1: JCExpression valueTree = translate(pair.snd);
duke@1: args.append(Assign(Ident(pair.fst), valueTree).setType(valueTree.type));
duke@1: }
duke@1: return Annotation(Type(compound.type), args.toList());
duke@1: }
duke@1: public void visitArray(Attribute.Array array) {
duke@1: ListBuffer elems = new ListBuffer();
duke@1: for (int i = 0; i < array.values.length; i++)
duke@1: elems.append(translate(array.values[i]));
duke@1: result = NewArray(null, List.nil(), elems.toList()).setType(array.type);
duke@1: }
duke@1: JCExpression translate(Attribute a) {
duke@1: a.accept(this);
duke@1: return result;
duke@1: }
duke@1: JCAnnotation translate(Attribute.Compound a) {
duke@1: return visitCompoundInternal(a);
duke@1: }
duke@1: }
duke@1: AnnotationBuilder annotationBuilder = new AnnotationBuilder();
duke@1:
duke@1: /** Create an annotation tree from an attribute.
duke@1: */
duke@1: public JCAnnotation Annotation(Attribute a) {
duke@1: return annotationBuilder.translate((Attribute.Compound)a);
duke@1: }
duke@1:
duke@1: /** Create a method definition from a method symbol and a method body.
duke@1: */
duke@1: public JCMethodDecl MethodDef(MethodSymbol m, JCBlock body) {
duke@1: return MethodDef(m, m.type, body);
duke@1: }
duke@1:
duke@1: /** Create a method definition from a method symbol, method type
duke@1: * and a method body.
duke@1: */
duke@1: public JCMethodDecl MethodDef(MethodSymbol m, Type mtype, JCBlock body) {
duke@1: return (JCMethodDecl)
duke@1: new JCMethodDecl(
duke@1: Modifiers(m.flags(), Annotations(m.getAnnotationMirrors())),
duke@1: m.name,
duke@1: Type(mtype.getReturnType()),
duke@1: TypeParams(mtype.getTypeArguments()),
duke@1: Params(mtype.getParameterTypes(), m),
duke@1: Types(mtype.getThrownTypes()),
duke@1: body,
duke@1: null,
duke@1: m).setPos(pos).setType(mtype);
duke@1: }
duke@1:
duke@1: /** Create a type parameter tree from its name and type.
duke@1: */
duke@1: public JCTypeParameter TypeParam(Name name, TypeVar tvar) {
duke@1: return (JCTypeParameter)
duke@1: TypeParameter(name, Types(types.getBounds(tvar))).setPos(pos).setType(tvar);
duke@1: }
duke@1:
duke@1: /** Create a list of type parameter trees from a list of type variables.
duke@1: */
duke@1: public List TypeParams(List typarams) {
duke@1: ListBuffer tparams = new ListBuffer();
duke@1: int i = 0;
duke@1: for (List l = typarams; l.nonEmpty(); l = l.tail)
duke@1: tparams.append(TypeParam(l.head.tsym.name, (TypeVar)l.head));
duke@1: return tparams.toList();
duke@1: }
duke@1:
duke@1: /** Create a value parameter tree from its name, type, and owner.
duke@1: */
duke@1: public JCVariableDecl Param(Name name, Type argtype, Symbol owner) {
duke@1: return VarDef(new VarSymbol(0, name, argtype, owner), null);
duke@1: }
duke@1:
duke@1: /** Create a a list of value parameter trees x0, ..., xn from a list of
duke@1: * their types and an their owner.
duke@1: */
duke@1: public List Params(List argtypes, Symbol owner) {
duke@1: ListBuffer params = new ListBuffer();
duke@1: MethodSymbol mth = (owner.kind == MTH) ? ((MethodSymbol)owner) : null;
duke@1: if (mth != null && mth.params != null && argtypes.length() == mth.params.length()) {
duke@1: for (VarSymbol param : ((MethodSymbol)owner).params)
duke@1: params.append(VarDef(param, null));
duke@1: } else {
duke@1: int i = 0;
duke@1: for (List l = argtypes; l.nonEmpty(); l = l.tail)
duke@1: params.append(Param(paramName(i++), l.head, owner));
duke@1: }
duke@1: return params.toList();
duke@1: }
duke@1:
duke@1: /** Wrap a method invocation in an expression statement or return statement,
duke@1: * depending on whether the method invocation expression's type is void.
duke@1: */
duke@1: public JCStatement Call(JCExpression apply) {
duke@1: return apply.type.tag == VOID ? Exec(apply) : Return(apply);
duke@1: }
duke@1:
duke@1: /** Construct an assignment from a variable symbol and a right hand side.
duke@1: */
duke@1: public JCStatement Assignment(Symbol v, JCExpression rhs) {
duke@1: return Exec(Assign(Ident(v), rhs).setType(v.type));
duke@1: }
duke@1:
duke@1: /** Construct an index expression from a variable and an expression.
duke@1: */
duke@1: public JCArrayAccess Indexed(Symbol v, JCExpression index) {
duke@1: JCArrayAccess tree = new JCArrayAccess(QualIdent(v), index);
duke@1: tree.type = ((ArrayType)v.type).elemtype;
duke@1: return tree;
duke@1: }
duke@1:
duke@1: /** Make an attributed type cast expression.
duke@1: */
duke@1: public JCTypeCast TypeCast(Type type, JCExpression expr) {
duke@1: return (JCTypeCast)TypeCast(Type(type), expr).setType(type);
duke@1: }
duke@1:
duke@1: /* ***************************************************************************
duke@1: * Helper methods.
duke@1: ****************************************************************************/
duke@1:
duke@1: /** Can given symbol be referred to in unqualified form?
duke@1: */
duke@1: boolean isUnqualifiable(Symbol sym) {
duke@1: if (sym.name == names.empty ||
duke@1: sym.owner == null ||
duke@1: sym.owner.kind == MTH || sym.owner.kind == VAR) {
duke@1: return true;
duke@1: } else if (sym.kind == TYP && toplevel != null) {
duke@1: Scope.Entry e;
duke@1: e = toplevel.namedImportScope.lookup(sym.name);
duke@1: if (e.scope != null) {
duke@1: return
duke@1: e.sym == sym &&
duke@1: e.next().scope == null;
duke@1: }
duke@1: e = toplevel.packge.members().lookup(sym.name);
duke@1: if (e.scope != null) {
duke@1: return
duke@1: e.sym == sym &&
duke@1: e.next().scope == null;
duke@1: }
duke@1: e = toplevel.starImportScope.lookup(sym.name);
duke@1: if (e.scope != null) {
duke@1: return
duke@1: e.sym == sym &&
duke@1: e.next().scope == null;
duke@1: }
duke@1: }
duke@1: return false;
duke@1: }
duke@1:
duke@1: /** The name of synthetic parameter number `i'.
duke@1: */
duke@1: public Name paramName(int i) { return names.fromString("x" + i); }
duke@1:
duke@1: /** The name of synthetic type parameter number `i'.
duke@1: */
duke@1: public Name typaramName(int i) { return names.fromString("A" + i); }
duke@1: }