duke@1: /*
xdono@117: * Copyright 1999-2008 Sun Microsystems, Inc. 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
duke@1: * published by the Free Software Foundation. Sun designates this
duke@1: * particular file as subject to the "Classpath" exception as provided
duke@1: * by Sun 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: *
duke@1: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@1: * CA 95054 USA or visit www.sun.com if you need additional information or
duke@1: * have any questions.
duke@1: */
duke@1:
duke@1: package com.sun.tools.javac.tree;
duke@1:
duke@1: import java.util.*;
duke@1:
duke@1: import java.io.IOException;
duke@1: import java.io.StringWriter;
duke@1: import javax.lang.model.element.Modifier;
duke@1: import javax.lang.model.type.TypeKind;
duke@1: import javax.tools.JavaFileObject;
duke@1:
duke@1: import com.sun.tools.javac.util.*;
duke@1: import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
duke@1: import com.sun.tools.javac.util.List;
duke@1: import com.sun.tools.javac.code.*;
duke@1: import com.sun.tools.javac.code.Scope;
duke@1: import com.sun.tools.javac.code.Symbol.*;
duke@1: import com.sun.source.tree.*;
duke@1:
duke@1: import static com.sun.tools.javac.code.BoundKind.*;
duke@1:
duke@1: /**
duke@1: * Root class for abstract syntax tree nodes. It provides definitions
duke@1: * for specific tree nodes as subclasses nested inside.
duke@1: *
duke@1: * Each subclass is highly standardized. It generally contains
duke@1: * only tree fields for the syntactic subcomponents of the node. Some
duke@1: * classes that represent identifier uses or definitions also define a
duke@1: * Symbol field that denotes the represented identifier. Classes for
duke@1: * non-local jumps also carry the jump target as a field. The root
duke@1: * class Tree itself defines fields for the tree's type and position.
duke@1: * No other fields are kept in a tree node; instead parameters are
duke@1: * passed to methods accessing the node.
duke@1: *
duke@1: *
Except for the methods defined by com.sun.source, the only
duke@1: * method defined in subclasses is `visit' which applies a given
duke@1: * visitor to the tree. The actual tree processing is done by visitor
duke@1: * classes in other packages. The abstract class Visitor, as well as
duke@1: * an Factory interface for trees, are defined as inner classes in
duke@1: * Tree.
duke@1: *
duke@1: *
To avoid ambiguities with the Tree API in com.sun.source all sub
duke@1: * classes should, by convention, start with JC (javac).
duke@1: *
duke@1: *
This is NOT part of any API supported by Sun Microsystems.
duke@1: * 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: * @see TreeMaker
duke@1: * @see TreeInfo
duke@1: * @see TreeTranslator
duke@1: * @see Pretty
duke@1: */
duke@1: public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
duke@1:
duke@1: /* Tree tag values, identifying kinds of trees */
duke@1:
duke@1: /** Toplevel nodes, of type TopLevel, representing entire source files.
duke@1: */
duke@1: public static final int TOPLEVEL = 1;
duke@1:
duke@1: /** Import clauses, of type Import.
duke@1: */
duke@1: public static final int IMPORT = TOPLEVEL + 1;
duke@1:
duke@1: /** Class definitions, of type ClassDef.
duke@1: */
duke@1: public static final int CLASSDEF = IMPORT + 1;
duke@1:
duke@1: /** Method definitions, of type MethodDef.
duke@1: */
duke@1: public static final int METHODDEF = CLASSDEF + 1;
duke@1:
duke@1: /** Variable definitions, of type VarDef.
duke@1: */
duke@1: public static final int VARDEF = METHODDEF + 1;
duke@1:
duke@1: /** The no-op statement ";", of type Skip
duke@1: */
duke@1: public static final int SKIP = VARDEF + 1;
duke@1:
duke@1: /** Blocks, of type Block.
duke@1: */
duke@1: public static final int BLOCK = SKIP + 1;
duke@1:
duke@1: /** Do-while loops, of type DoLoop.
duke@1: */
duke@1: public static final int DOLOOP = BLOCK + 1;
duke@1:
duke@1: /** While-loops, of type WhileLoop.
duke@1: */
duke@1: public static final int WHILELOOP = DOLOOP + 1;
duke@1:
duke@1: /** For-loops, of type ForLoop.
duke@1: */
duke@1: public static final int FORLOOP = WHILELOOP + 1;
duke@1:
duke@1: /** Foreach-loops, of type ForeachLoop.
duke@1: */
duke@1: public static final int FOREACHLOOP = FORLOOP + 1;
duke@1:
duke@1: /** Labelled statements, of type Labelled.
duke@1: */
duke@1: public static final int LABELLED = FOREACHLOOP + 1;
duke@1:
duke@1: /** Switch statements, of type Switch.
duke@1: */
duke@1: public static final int SWITCH = LABELLED + 1;
duke@1:
duke@1: /** Case parts in switch statements, of type Case.
duke@1: */
duke@1: public static final int CASE = SWITCH + 1;
duke@1:
duke@1: /** Synchronized statements, of type Synchonized.
duke@1: */
duke@1: public static final int SYNCHRONIZED = CASE + 1;
duke@1:
duke@1: /** Try statements, of type Try.
duke@1: */
duke@1: public static final int TRY = SYNCHRONIZED + 1;
duke@1:
duke@1: /** Catch clauses in try statements, of type Catch.
duke@1: */
duke@1: public static final int CATCH = TRY + 1;
duke@1:
duke@1: /** Conditional expressions, of type Conditional.
duke@1: */
duke@1: public static final int CONDEXPR = CATCH + 1;
duke@1:
duke@1: /** Conditional statements, of type If.
duke@1: */
duke@1: public static final int IF = CONDEXPR + 1;
duke@1:
duke@1: /** Expression statements, of type Exec.
duke@1: */
duke@1: public static final int EXEC = IF + 1;
duke@1:
duke@1: /** Break statements, of type Break.
duke@1: */
duke@1: public static final int BREAK = EXEC + 1;
duke@1:
duke@1: /** Continue statements, of type Continue.
duke@1: */
duke@1: public static final int CONTINUE = BREAK + 1;
duke@1:
duke@1: /** Return statements, of type Return.
duke@1: */
duke@1: public static final int RETURN = CONTINUE + 1;
duke@1:
duke@1: /** Throw statements, of type Throw.
duke@1: */
duke@1: public static final int THROW = RETURN + 1;
duke@1:
duke@1: /** Assert statements, of type Assert.
duke@1: */
duke@1: public static final int ASSERT = THROW + 1;
duke@1:
duke@1: /** Method invocation expressions, of type Apply.
duke@1: */
duke@1: public static final int APPLY = ASSERT + 1;
duke@1:
duke@1: /** Class instance creation expressions, of type NewClass.
duke@1: */
duke@1: public static final int NEWCLASS = APPLY + 1;
duke@1:
duke@1: /** Array creation expressions, of type NewArray.
duke@1: */
duke@1: public static final int NEWARRAY = NEWCLASS + 1;
duke@1:
duke@1: /** Parenthesized subexpressions, of type Parens.
duke@1: */
duke@1: public static final int PARENS = NEWARRAY + 1;
duke@1:
duke@1: /** Assignment expressions, of type Assign.
duke@1: */
duke@1: public static final int ASSIGN = PARENS + 1;
duke@1:
duke@1: /** Type cast expressions, of type TypeCast.
duke@1: */
duke@1: public static final int TYPECAST = ASSIGN + 1;
duke@1:
duke@1: /** Type test expressions, of type TypeTest.
duke@1: */
duke@1: public static final int TYPETEST = TYPECAST + 1;
duke@1:
duke@1: /** Indexed array expressions, of type Indexed.
duke@1: */
duke@1: public static final int INDEXED = TYPETEST + 1;
duke@1:
duke@1: /** Selections, of type Select.
duke@1: */
duke@1: public static final int SELECT = INDEXED + 1;
duke@1:
duke@1: /** Simple identifiers, of type Ident.
duke@1: */
duke@1: public static final int IDENT = SELECT + 1;
duke@1:
duke@1: /** Literals, of type Literal.
duke@1: */
duke@1: public static final int LITERAL = IDENT + 1;
duke@1:
duke@1: /** Basic type identifiers, of type TypeIdent.
duke@1: */
duke@1: public static final int TYPEIDENT = LITERAL + 1;
duke@1:
duke@1: /** Array types, of type TypeArray.
duke@1: */
duke@1: public static final int TYPEARRAY = TYPEIDENT + 1;
duke@1:
duke@1: /** Parameterized types, of type TypeApply.
duke@1: */
duke@1: public static final int TYPEAPPLY = TYPEARRAY + 1;
duke@1:
duke@1: /** Formal type parameters, of type TypeParameter.
duke@1: */
duke@1: public static final int TYPEPARAMETER = TYPEAPPLY + 1;
duke@1:
duke@1: /** Type argument.
duke@1: */
duke@1: public static final int WILDCARD = TYPEPARAMETER + 1;
duke@1:
duke@1: /** Bound kind: extends, super, exact, or unbound
duke@1: */
duke@1: public static final int TYPEBOUNDKIND = WILDCARD + 1;
duke@1:
duke@1: /** metadata: Annotation.
duke@1: */
duke@1: public static final int ANNOTATION = TYPEBOUNDKIND + 1;
duke@1:
duke@1: /** metadata: Modifiers
duke@1: */
duke@1: public static final int MODIFIERS = ANNOTATION + 1;
duke@1:
duke@1: /** Error trees, of type Erroneous.
duke@1: */
duke@1: public static final int ERRONEOUS = MODIFIERS + 1;
duke@1:
duke@1: /** Unary operators, of type Unary.
duke@1: */
duke@1: public static final int POS = ERRONEOUS + 1; // +
duke@1: public static final int NEG = POS + 1; // -
duke@1: public static final int NOT = NEG + 1; // !
duke@1: public static final int COMPL = NOT + 1; // ~
duke@1: public static final int PREINC = COMPL + 1; // ++ _
duke@1: public static final int PREDEC = PREINC + 1; // -- _
duke@1: public static final int POSTINC = PREDEC + 1; // _ ++
duke@1: public static final int POSTDEC = POSTINC + 1; // _ --
duke@1:
duke@1: /** unary operator for null reference checks, only used internally.
duke@1: */
duke@1: public static final int NULLCHK = POSTDEC + 1;
duke@1:
duke@1: /** Binary operators, of type Binary.
duke@1: */
duke@1: public static final int OR = NULLCHK + 1; // ||
duke@1: public static final int AND = OR + 1; // &&
duke@1: public static final int BITOR = AND + 1; // |
duke@1: public static final int BITXOR = BITOR + 1; // ^
duke@1: public static final int BITAND = BITXOR + 1; // &
duke@1: public static final int EQ = BITAND + 1; // ==
duke@1: public static final int NE = EQ + 1; // !=
duke@1: public static final int LT = NE + 1; // <
duke@1: public static final int GT = LT + 1; // >
duke@1: public static final int LE = GT + 1; // <=
duke@1: public static final int GE = LE + 1; // >=
duke@1: public static final int SL = GE + 1; // <<
duke@1: public static final int SR = SL + 1; // >>
duke@1: public static final int USR = SR + 1; // >>>
duke@1: public static final int PLUS = USR + 1; // +
duke@1: public static final int MINUS = PLUS + 1; // -
duke@1: public static final int MUL = MINUS + 1; // *
duke@1: public static final int DIV = MUL + 1; // /
duke@1: public static final int MOD = DIV + 1; // %
duke@1:
duke@1: /** Assignment operators, of type Assignop.
duke@1: */
duke@1: public static final int BITOR_ASG = MOD + 1; // |=
duke@1: public static final int BITXOR_ASG = BITOR_ASG + 1; // ^=
duke@1: public static final int BITAND_ASG = BITXOR_ASG + 1; // &=
duke@1:
duke@1: public static final int SL_ASG = SL + BITOR_ASG - BITOR; // <<=
duke@1: public static final int SR_ASG = SL_ASG + 1; // >>=
duke@1: public static final int USR_ASG = SR_ASG + 1; // >>>=
duke@1: public static final int PLUS_ASG = USR_ASG + 1; // +=
duke@1: public static final int MINUS_ASG = PLUS_ASG + 1; // -=
duke@1: public static final int MUL_ASG = MINUS_ASG + 1; // *=
duke@1: public static final int DIV_ASG = MUL_ASG + 1; // /=
duke@1: public static final int MOD_ASG = DIV_ASG + 1; // %=
duke@1:
duke@1: /** A synthetic let expression, of type LetExpr.
duke@1: */
duke@1: public static final int LETEXPR = MOD_ASG + 1; // ala scheme
duke@1:
duke@1:
duke@1: /** The offset between assignment operators and normal operators.
duke@1: */
duke@1: public static final int ASGOffset = BITOR_ASG - BITOR;
duke@1:
duke@1: /* The (encoded) position in the source file. @see util.Position.
duke@1: */
duke@1: public int pos;
duke@1:
duke@1: /* The type of this node.
duke@1: */
duke@1: public Type type;
duke@1:
duke@1: /* The tag of this node -- one of the constants declared above.
duke@1: */
duke@1: public abstract int getTag();
duke@1:
duke@1: /** Convert a tree to a pretty-printed string. */
duke@1: public String toString() {
duke@1: StringWriter s = new StringWriter();
duke@1: try {
duke@1: new Pretty(s, false).printExpr(this);
duke@1: }
duke@1: catch (IOException e) {
duke@1: // should never happen, because StringWriter is defined
duke@1: // never to throw any IOExceptions
duke@1: throw new AssertionError(e);
duke@1: }
duke@1: return s.toString();
duke@1: }
duke@1:
duke@1: /** Set position field and return this tree.
duke@1: */
duke@1: public JCTree setPos(int pos) {
duke@1: this.pos = pos;
duke@1: return this;
duke@1: }
duke@1:
duke@1: /** Set type field and return this tree.
duke@1: */
duke@1: public JCTree setType(Type type) {
duke@1: this.type = type;
duke@1: return this;
duke@1: }
duke@1:
duke@1: /** Visit this tree with a given visitor.
duke@1: */
duke@1: public abstract void accept(Visitor v);
duke@1:
duke@1: public abstract R accept(TreeVisitor v, D d);
duke@1:
duke@1: /** Return a shallow copy of this tree.
duke@1: */
duke@1: public Object clone() {
duke@1: try {
duke@1: return super.clone();
duke@1: } catch(CloneNotSupportedException e) {
duke@1: throw new RuntimeException(e);
duke@1: }
duke@1: }
duke@1:
duke@1: /** Get a default position for this tree node.
duke@1: */
duke@1: public DiagnosticPosition pos() {
duke@1: return this;
duke@1: }
duke@1:
duke@1: // for default DiagnosticPosition
duke@1: public JCTree getTree() {
duke@1: return this;
duke@1: }
duke@1:
duke@1: // for default DiagnosticPosition
duke@1: public int getStartPosition() {
duke@1: return TreeInfo.getStartPos(this);
duke@1: }
duke@1:
duke@1: // for default DiagnosticPosition
duke@1: public int getPreferredPosition() {
duke@1: return pos;
duke@1: }
duke@1:
duke@1: // for default DiagnosticPosition
duke@1: public int getEndPosition(Map endPosTable) {
duke@1: return TreeInfo.getEndPos(this, endPosTable);
duke@1: }
duke@1:
duke@1: /**
duke@1: * Everything in one source file is kept in a TopLevel structure.
duke@1: * @param pid The tree representing the package clause.
duke@1: * @param sourcefile The source file name.
duke@1: * @param defs All definitions in this file (ClassDef, Import, and Skip)
duke@1: * @param packge The package it belongs to.
duke@1: * @param namedImportScope A scope for all named imports.
duke@1: * @param starImportScope A scope for all import-on-demands.
duke@1: * @param lineMap Line starting positions, defined only
duke@1: * if option -g is set.
duke@1: * @param docComments A hashtable that stores all documentation comments
duke@1: * indexed by the tree nodes they refer to.
duke@1: * defined only if option -s is set.
duke@1: * @param endPositions A hashtable that stores ending positions of source
duke@1: * ranges indexed by the tree nodes they belong to.
duke@1: * Defined only if option -Xjcov is set.
duke@1: */
duke@1: public static class JCCompilationUnit extends JCTree implements CompilationUnitTree {
duke@1: public List packageAnnotations;
duke@1: public JCExpression pid;
duke@1: public List defs;
duke@1: public JavaFileObject sourcefile;
duke@1: public PackageSymbol packge;
duke@1: public Scope namedImportScope;
duke@1: public Scope starImportScope;
duke@1: public long flags;
duke@1: public Position.LineMap lineMap = null;
duke@1: public Map docComments = null;
duke@1: public Map endPositions = null;
duke@1: protected JCCompilationUnit(List packageAnnotations,
duke@1: JCExpression pid,
duke@1: List defs,
duke@1: JavaFileObject sourcefile,
duke@1: PackageSymbol packge,
duke@1: Scope namedImportScope,
duke@1: Scope starImportScope) {
duke@1: this.packageAnnotations = packageAnnotations;
duke@1: this.pid = pid;
duke@1: this.defs = defs;
duke@1: this.sourcefile = sourcefile;
duke@1: this.packge = packge;
duke@1: this.namedImportScope = namedImportScope;
duke@1: this.starImportScope = starImportScope;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTopLevel(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.COMPILATION_UNIT; }
duke@1: public List getPackageAnnotations() {
duke@1: return packageAnnotations;
duke@1: }
duke@1: public List getImports() {
duke@1: ListBuffer imports = new ListBuffer();
duke@1: for (JCTree tree : defs) {
duke@1: if (tree.getTag() == IMPORT)
duke@1: imports.append((JCImport)tree);
duke@1: else
duke@1: break;
duke@1: }
duke@1: return imports.toList();
duke@1: }
duke@1: public JCExpression getPackageName() { return pid; }
duke@1: public JavaFileObject getSourceFile() {
duke@1: return sourcefile;
duke@1: }
duke@1: public Position.LineMap getLineMap() {
duke@1: return lineMap;
duke@1: }
duke@1: public List getTypeDecls() {
duke@1: List typeDefs;
duke@1: for (typeDefs = defs; !typeDefs.isEmpty(); typeDefs = typeDefs.tail)
duke@1: if (typeDefs.head.getTag() != IMPORT)
duke@1: break;
duke@1: return typeDefs;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitCompilationUnit(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TOPLEVEL;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * An import clause.
duke@1: * @param qualid The imported class(es).
duke@1: */
duke@1: public static class JCImport extends JCTree implements ImportTree {
duke@1: public boolean staticImport;
duke@1: public JCTree qualid;
duke@1: protected JCImport(JCTree qualid, boolean importStatic) {
duke@1: this.qualid = qualid;
duke@1: this.staticImport = importStatic;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitImport(this); }
duke@1:
duke@1: public boolean isStatic() { return staticImport; }
duke@1: public JCTree getQualifiedIdentifier() { return qualid; }
duke@1:
duke@1: public Kind getKind() { return Kind.IMPORT; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitImport(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return IMPORT;
duke@1: }
duke@1: }
duke@1:
duke@1: public static abstract class JCStatement extends JCTree implements StatementTree {
duke@1: @Override
duke@1: public JCStatement setType(Type type) {
duke@1: super.setType(type);
duke@1: return this;
duke@1: }
duke@1: @Override
duke@1: public JCStatement setPos(int pos) {
duke@1: super.setPos(pos);
duke@1: return this;
duke@1: }
duke@1: }
duke@1:
duke@1: public static abstract class JCExpression extends JCTree implements ExpressionTree {
duke@1: @Override
duke@1: public JCExpression setType(Type type) {
duke@1: super.setType(type);
duke@1: return this;
duke@1: }
duke@1: @Override
duke@1: public JCExpression setPos(int pos) {
duke@1: super.setPos(pos);
duke@1: return this;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A class definition.
duke@1: * @param modifiers the modifiers
duke@1: * @param name the name of the class
duke@1: * @param typarams formal class parameters
duke@1: * @param extending the classes this class extends
duke@1: * @param implementing the interfaces implemented by this class
duke@1: * @param defs all variables and methods defined in this class
duke@1: * @param sym the symbol
duke@1: */
duke@1: public static class JCClassDecl extends JCStatement implements ClassTree {
duke@1: public JCModifiers mods;
duke@1: public Name name;
duke@1: public List typarams;
duke@1: public JCTree extending;
duke@1: public List implementing;
duke@1: public List defs;
duke@1: public ClassSymbol sym;
duke@1: protected JCClassDecl(JCModifiers mods,
duke@1: Name name,
duke@1: List typarams,
duke@1: JCTree extending,
duke@1: List implementing,
duke@1: List defs,
duke@1: ClassSymbol sym)
duke@1: {
duke@1: this.mods = mods;
duke@1: this.name = name;
duke@1: this.typarams = typarams;
duke@1: this.extending = extending;
duke@1: this.implementing = implementing;
duke@1: this.defs = defs;
duke@1: this.sym = sym;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitClassDef(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.CLASS; }
duke@1: public JCModifiers getModifiers() { return mods; }
duke@1: public Name getSimpleName() { return name; }
duke@1: public List getTypeParameters() {
duke@1: return typarams;
duke@1: }
duke@1: public JCTree getExtendsClause() { return extending; }
duke@1: public List getImplementsClause() {
duke@1: return implementing;
duke@1: }
duke@1: public List getMembers() {
duke@1: return defs;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitClass(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return CLASSDEF;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A method definition.
duke@1: * @param modifiers method modifiers
duke@1: * @param name method name
duke@1: * @param restype type of method return value
duke@1: * @param typarams type parameters
duke@1: * @param params value parameters
duke@1: * @param thrown exceptions thrown by this method
duke@1: * @param stats statements in the method
duke@1: * @param sym method symbol
duke@1: */
duke@1: public static class JCMethodDecl extends JCTree implements MethodTree {
duke@1: public JCModifiers mods;
duke@1: public Name name;
duke@1: public JCExpression restype;
duke@1: public List typarams;
duke@1: public List params;
duke@1: public List thrown;
duke@1: public JCBlock body;
duke@1: public JCExpression defaultValue; // for annotation types
duke@1: public MethodSymbol sym;
duke@1: protected JCMethodDecl(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,
duke@1: JCExpression defaultValue,
duke@1: MethodSymbol sym)
duke@1: {
duke@1: this.mods = mods;
duke@1: this.name = name;
duke@1: this.restype = restype;
duke@1: this.typarams = typarams;
duke@1: this.params = params;
duke@1: this.thrown = thrown;
duke@1: this.body = body;
duke@1: this.defaultValue = defaultValue;
duke@1: this.sym = sym;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitMethodDef(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.METHOD; }
duke@1: public JCModifiers getModifiers() { return mods; }
duke@1: public Name getName() { return name; }
duke@1: public JCTree getReturnType() { return restype; }
duke@1: public List getTypeParameters() {
duke@1: return typarams;
duke@1: }
duke@1: public List getParameters() {
duke@1: return params;
duke@1: }
duke@1: public List getThrows() {
duke@1: return thrown;
duke@1: }
duke@1: public JCBlock getBody() { return body; }
duke@1: public JCTree getDefaultValue() { // for annotation types
duke@1: return defaultValue;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitMethod(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return METHODDEF;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A variable definition.
duke@1: * @param modifiers variable modifiers
duke@1: * @param name variable name
duke@1: * @param vartype type of the variable
duke@1: * @param init variables initial value
duke@1: * @param sym symbol
duke@1: */
duke@1: public static class JCVariableDecl extends JCStatement implements VariableTree {
duke@1: public JCModifiers mods;
duke@1: public Name name;
duke@1: public JCExpression vartype;
duke@1: public JCExpression init;
duke@1: public VarSymbol sym;
duke@1: protected JCVariableDecl(JCModifiers mods,
duke@1: Name name,
duke@1: JCExpression vartype,
duke@1: JCExpression init,
duke@1: VarSymbol sym) {
duke@1: this.mods = mods;
duke@1: this.name = name;
duke@1: this.vartype = vartype;
duke@1: this.init = init;
duke@1: this.sym = sym;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitVarDef(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.VARIABLE; }
duke@1: public JCModifiers getModifiers() { return mods; }
duke@1: public Name getName() { return name; }
duke@1: public JCTree getType() { return vartype; }
duke@1: public JCExpression getInitializer() {
duke@1: return init;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitVariable(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return VARDEF;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A no-op statement ";".
duke@1: */
duke@1: public static class JCSkip extends JCStatement implements EmptyStatementTree {
duke@1: protected JCSkip() {
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitSkip(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.EMPTY_STATEMENT; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitEmptyStatement(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return SKIP;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A statement block.
duke@1: * @param stats statements
duke@1: * @param flags flags
duke@1: */
duke@1: public static class JCBlock extends JCStatement implements BlockTree {
duke@1: public long flags;
duke@1: public List stats;
duke@1: /** Position of closing brace, optional. */
duke@1: public int endpos = Position.NOPOS;
duke@1: protected JCBlock(long flags, List stats) {
duke@1: this.stats = stats;
duke@1: this.flags = flags;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitBlock(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.BLOCK; }
duke@1: public List getStatements() {
duke@1: return stats;
duke@1: }
duke@1: public boolean isStatic() { return (flags & Flags.STATIC) != 0; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitBlock(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return BLOCK;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A do loop
duke@1: */
duke@1: public static class JCDoWhileLoop extends JCStatement implements DoWhileLoopTree {
duke@1: public JCStatement body;
duke@1: public JCExpression cond;
duke@1: protected JCDoWhileLoop(JCStatement body, JCExpression cond) {
duke@1: this.body = body;
duke@1: this.cond = cond;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitDoLoop(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.DO_WHILE_LOOP; }
duke@1: public JCExpression getCondition() { return cond; }
duke@1: public JCStatement getStatement() { return body; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitDoWhileLoop(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return DOLOOP;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A while loop
duke@1: */
duke@1: public static class JCWhileLoop extends JCStatement implements WhileLoopTree {
duke@1: public JCExpression cond;
duke@1: public JCStatement body;
duke@1: protected JCWhileLoop(JCExpression cond, JCStatement body) {
duke@1: this.cond = cond;
duke@1: this.body = body;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitWhileLoop(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.WHILE_LOOP; }
duke@1: public JCExpression getCondition() { return cond; }
duke@1: public JCStatement getStatement() { return body; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitWhileLoop(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return WHILELOOP;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A for loop.
duke@1: */
duke@1: public static class JCForLoop extends JCStatement implements ForLoopTree {
duke@1: public List init;
duke@1: public JCExpression cond;
duke@1: public List step;
duke@1: public JCStatement body;
duke@1: protected JCForLoop(List init,
duke@1: JCExpression cond,
duke@1: List update,
duke@1: JCStatement body)
duke@1: {
duke@1: this.init = init;
duke@1: this.cond = cond;
duke@1: this.step = update;
duke@1: this.body = body;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitForLoop(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.FOR_LOOP; }
duke@1: public JCExpression getCondition() { return cond; }
duke@1: public JCStatement getStatement() { return body; }
duke@1: public List getInitializer() {
duke@1: return init;
duke@1: }
duke@1: public List getUpdate() {
duke@1: return step;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitForLoop(this, d);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int getTag() {
duke@1: return FORLOOP;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * The enhanced for loop.
duke@1: */
duke@1: public static class JCEnhancedForLoop extends JCStatement implements EnhancedForLoopTree {
duke@1: public JCVariableDecl var;
duke@1: public JCExpression expr;
duke@1: public JCStatement body;
duke@1: protected JCEnhancedForLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {
duke@1: this.var = var;
duke@1: this.expr = expr;
duke@1: this.body = body;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitForeachLoop(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.ENHANCED_FOR_LOOP; }
duke@1: public JCVariableDecl getVariable() { return var; }
duke@1: public JCExpression getExpression() { return expr; }
duke@1: public JCStatement getStatement() { return body; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitEnhancedForLoop(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return FOREACHLOOP;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A labelled expression or statement.
duke@1: */
duke@1: public static class JCLabeledStatement extends JCStatement implements LabeledStatementTree {
duke@1: public Name label;
duke@1: public JCStatement body;
duke@1: protected JCLabeledStatement(Name label, JCStatement body) {
duke@1: this.label = label;
duke@1: this.body = body;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitLabelled(this); }
duke@1: public Kind getKind() { return Kind.LABELED_STATEMENT; }
duke@1: public Name getLabel() { return label; }
duke@1: public JCStatement getStatement() { return body; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitLabeledStatement(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return LABELLED;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A "switch ( ) { }" construction.
duke@1: */
duke@1: public static class JCSwitch extends JCStatement implements SwitchTree {
duke@1: public JCExpression selector;
duke@1: public List cases;
duke@1: protected JCSwitch(JCExpression selector, List cases) {
duke@1: this.selector = selector;
duke@1: this.cases = cases;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitSwitch(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.SWITCH; }
duke@1: public JCExpression getExpression() { return selector; }
duke@1: public List getCases() { return cases; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitSwitch(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return SWITCH;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A "case :" of a switch.
duke@1: */
duke@1: public static class JCCase extends JCStatement implements CaseTree {
duke@1: public JCExpression pat;
duke@1: public List stats;
duke@1: protected JCCase(JCExpression pat, List stats) {
duke@1: this.pat = pat;
duke@1: this.stats = stats;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitCase(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.CASE; }
duke@1: public JCExpression getExpression() { return pat; }
duke@1: public List getStatements() { return stats; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitCase(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return CASE;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A synchronized block.
duke@1: */
duke@1: public static class JCSynchronized extends JCStatement implements SynchronizedTree {
duke@1: public JCExpression lock;
duke@1: public JCBlock body;
duke@1: protected JCSynchronized(JCExpression lock, JCBlock body) {
duke@1: this.lock = lock;
duke@1: this.body = body;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitSynchronized(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.SYNCHRONIZED; }
duke@1: public JCExpression getExpression() { return lock; }
duke@1: public JCBlock getBlock() { return body; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitSynchronized(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return SYNCHRONIZED;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A "try { } catch ( ) { } finally { }" block.
duke@1: */
duke@1: public static class JCTry extends JCStatement implements TryTree {
duke@1: public JCBlock body;
duke@1: public List catchers;
duke@1: public JCBlock finalizer;
duke@1: protected JCTry(JCBlock body, List catchers, JCBlock finalizer) {
duke@1: this.body = body;
duke@1: this.catchers = catchers;
duke@1: this.finalizer = finalizer;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTry(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.TRY; }
duke@1: public JCBlock getBlock() { return body; }
duke@1: public List getCatches() {
duke@1: return catchers;
duke@1: }
duke@1: public JCBlock getFinallyBlock() { return finalizer; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitTry(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TRY;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A catch block.
duke@1: */
duke@1: public static class JCCatch extends JCTree implements CatchTree {
duke@1: public JCVariableDecl param;
duke@1: public JCBlock body;
duke@1: protected JCCatch(JCVariableDecl param, JCBlock body) {
duke@1: this.param = param;
duke@1: this.body = body;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitCatch(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.CATCH; }
duke@1: public JCVariableDecl getParameter() { return param; }
duke@1: public JCBlock getBlock() { return body; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitCatch(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return CATCH;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A ( ) ? ( ) : ( ) conditional expression
duke@1: */
duke@1: public static class JCConditional extends JCExpression implements ConditionalExpressionTree {
duke@1: public JCExpression cond;
duke@1: public JCExpression truepart;
duke@1: public JCExpression falsepart;
duke@1: protected JCConditional(JCExpression cond,
duke@1: JCExpression truepart,
duke@1: JCExpression falsepart)
duke@1: {
duke@1: this.cond = cond;
duke@1: this.truepart = truepart;
duke@1: this.falsepart = falsepart;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitConditional(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.CONDITIONAL_EXPRESSION; }
duke@1: public JCExpression getCondition() { return cond; }
duke@1: public JCExpression getTrueExpression() { return truepart; }
duke@1: public JCExpression getFalseExpression() { return falsepart; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitConditionalExpression(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return CONDEXPR;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * An "if ( ) { } else { }" block
duke@1: */
duke@1: public static class JCIf extends JCStatement implements IfTree {
duke@1: public JCExpression cond;
duke@1: public JCStatement thenpart;
duke@1: public JCStatement elsepart;
duke@1: protected JCIf(JCExpression cond,
duke@1: JCStatement thenpart,
duke@1: JCStatement elsepart)
duke@1: {
duke@1: this.cond = cond;
duke@1: this.thenpart = thenpart;
duke@1: this.elsepart = elsepart;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitIf(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.IF; }
duke@1: public JCExpression getCondition() { return cond; }
duke@1: public JCStatement getThenStatement() { return thenpart; }
duke@1: public JCStatement getElseStatement() { return elsepart; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitIf(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return IF;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * an expression statement
duke@1: * @param expr expression structure
duke@1: */
duke@1: public static class JCExpressionStatement extends JCStatement implements ExpressionStatementTree {
duke@1: public JCExpression expr;
duke@1: protected JCExpressionStatement(JCExpression expr)
duke@1: {
duke@1: this.expr = expr;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitExec(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.EXPRESSION_STATEMENT; }
duke@1: public JCExpression getExpression() { return expr; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitExpressionStatement(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return EXEC;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A break from a loop or switch.
duke@1: */
duke@1: public static class JCBreak extends JCStatement implements BreakTree {
duke@1: public Name label;
duke@1: public JCTree target;
duke@1: protected JCBreak(Name label, JCTree target) {
duke@1: this.label = label;
duke@1: this.target = target;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitBreak(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.BREAK; }
duke@1: public Name getLabel() { return label; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitBreak(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return BREAK;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A continue of a loop.
duke@1: */
duke@1: public static class JCContinue extends JCStatement implements ContinueTree {
duke@1: public Name label;
duke@1: public JCTree target;
duke@1: protected JCContinue(Name label, JCTree target) {
duke@1: this.label = label;
duke@1: this.target = target;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitContinue(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.CONTINUE; }
duke@1: public Name getLabel() { return label; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitContinue(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return CONTINUE;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A return statement.
duke@1: */
duke@1: public static class JCReturn extends JCStatement implements ReturnTree {
duke@1: public JCExpression expr;
duke@1: protected JCReturn(JCExpression expr) {
duke@1: this.expr = expr;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitReturn(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.RETURN; }
duke@1: public JCExpression getExpression() { return expr; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitReturn(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return RETURN;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A throw statement.
duke@1: */
duke@1: public static class JCThrow extends JCStatement implements ThrowTree {
duke@1: public JCExpression expr;
duke@1: protected JCThrow(JCTree expr) {
duke@1: this.expr = (JCExpression)expr;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitThrow(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.THROW; }
duke@1: public JCExpression getExpression() { return expr; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitThrow(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return THROW;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * An assert statement.
duke@1: */
duke@1: public static class JCAssert extends JCStatement implements AssertTree {
duke@1: public JCExpression cond;
duke@1: public JCExpression detail;
duke@1: protected JCAssert(JCExpression cond, JCExpression detail) {
duke@1: this.cond = cond;
duke@1: this.detail = detail;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitAssert(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.ASSERT; }
duke@1: public JCExpression getCondition() { return cond; }
duke@1: public JCExpression getDetail() { return detail; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitAssert(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return ASSERT;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A method invocation
duke@1: */
duke@1: public static class JCMethodInvocation extends JCExpression implements MethodInvocationTree {
duke@1: public List typeargs;
duke@1: public JCExpression meth;
duke@1: public List args;
duke@1: public Type varargsElement;
duke@1: protected JCMethodInvocation(List typeargs,
duke@1: JCExpression meth,
duke@1: List args)
duke@1: {
duke@1: this.typeargs = (typeargs == null) ? List.nil()
duke@1: : typeargs;
duke@1: this.meth = meth;
duke@1: this.args = args;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitApply(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.METHOD_INVOCATION; }
duke@1: public List getTypeArguments() {
duke@1: return typeargs;
duke@1: }
duke@1: public JCExpression getMethodSelect() { return meth; }
duke@1: public List getArguments() {
duke@1: return args;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitMethodInvocation(this, d);
duke@1: }
duke@1: @Override
duke@1: public JCMethodInvocation setType(Type type) {
duke@1: super.setType(type);
duke@1: return this;
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return(APPLY);
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A new(...) operation.
duke@1: */
duke@1: public static class JCNewClass extends JCExpression implements NewClassTree {
duke@1: public JCExpression encl;
duke@1: public List typeargs;
duke@1: public JCExpression clazz;
duke@1: public List args;
duke@1: public JCClassDecl def;
duke@1: public Symbol constructor;
duke@1: public Type varargsElement;
mcimadamore@186: public Type constructorType;
duke@1: protected JCNewClass(JCExpression encl,
duke@1: List typeargs,
duke@1: JCExpression clazz,
duke@1: List args,
duke@1: JCClassDecl def)
duke@1: {
duke@1: this.encl = encl;
duke@1: this.typeargs = (typeargs == null) ? List.nil()
duke@1: : typeargs;
duke@1: this.clazz = clazz;
duke@1: this.args = args;
duke@1: this.def = def;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitNewClass(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.NEW_CLASS; }
duke@1: public JCExpression getEnclosingExpression() { // expr.new C< ... > ( ... )
duke@1: return encl;
duke@1: }
duke@1: public List getTypeArguments() {
duke@1: return typeargs;
duke@1: }
duke@1: public JCExpression getIdentifier() { return clazz; }
duke@1: public List getArguments() {
duke@1: return args;
duke@1: }
duke@1: public JCClassDecl getClassBody() { return def; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitNewClass(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return NEWCLASS;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A new[...] operation.
duke@1: */
duke@1: public static class JCNewArray extends JCExpression implements NewArrayTree {
duke@1: public JCExpression elemtype;
duke@1: public List dims;
duke@1: public List elems;
duke@1: protected JCNewArray(JCExpression elemtype,
duke@1: List dims,
duke@1: List elems)
duke@1: {
duke@1: this.elemtype = elemtype;
duke@1: this.dims = dims;
duke@1: this.elems = elems;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitNewArray(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.NEW_ARRAY; }
duke@1: public JCExpression getType() { return elemtype; }
duke@1: public List getDimensions() {
duke@1: return dims;
duke@1: }
duke@1: public List getInitializers() {
duke@1: return elems;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitNewArray(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return NEWARRAY;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A parenthesized subexpression ( ... )
duke@1: */
duke@1: public static class JCParens extends JCExpression implements ParenthesizedTree {
duke@1: public JCExpression expr;
duke@1: protected JCParens(JCExpression expr) {
duke@1: this.expr = expr;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitParens(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.PARENTHESIZED; }
duke@1: public JCExpression getExpression() { return expr; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitParenthesized(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return PARENS;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A assignment with "=".
duke@1: */
duke@1: public static class JCAssign extends JCExpression implements AssignmentTree {
duke@1: public JCExpression lhs;
duke@1: public JCExpression rhs;
duke@1: protected JCAssign(JCExpression lhs, JCExpression rhs) {
duke@1: this.lhs = lhs;
duke@1: this.rhs = rhs;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitAssign(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.ASSIGNMENT; }
duke@1: public JCExpression getVariable() { return lhs; }
duke@1: public JCExpression getExpression() { return rhs; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitAssignment(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return ASSIGN;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * An assignment with "+=", "|=" ...
duke@1: */
duke@1: public static class JCAssignOp extends JCExpression implements CompoundAssignmentTree {
duke@1: private int opcode;
duke@1: public JCExpression lhs;
duke@1: public JCExpression rhs;
duke@1: public Symbol operator;
duke@1: protected JCAssignOp(int opcode, JCTree lhs, JCTree rhs, Symbol operator) {
duke@1: this.opcode = opcode;
duke@1: this.lhs = (JCExpression)lhs;
duke@1: this.rhs = (JCExpression)rhs;
duke@1: this.operator = operator;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitAssignop(this); }
duke@1:
duke@1: public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
duke@1: public JCExpression getVariable() { return lhs; }
duke@1: public JCExpression getExpression() { return rhs; }
duke@1: public Symbol getOperator() {
duke@1: return operator;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitCompoundAssignment(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return opcode;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A unary operation.
duke@1: */
duke@1: public static class JCUnary extends JCExpression implements UnaryTree {
duke@1: private int opcode;
duke@1: public JCExpression arg;
duke@1: public Symbol operator;
duke@1: protected JCUnary(int opcode, JCExpression arg) {
duke@1: this.opcode = opcode;
duke@1: this.arg = arg;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitUnary(this); }
duke@1:
duke@1: public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
duke@1: public JCExpression getExpression() { return arg; }
duke@1: public Symbol getOperator() {
duke@1: return operator;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitUnary(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return opcode;
duke@1: }
duke@1:
duke@1: public void setTag(int tag) {
duke@1: opcode = tag;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A binary operation.
duke@1: */
duke@1: public static class JCBinary extends JCExpression implements BinaryTree {
duke@1: private int opcode;
duke@1: public JCExpression lhs;
duke@1: public JCExpression rhs;
duke@1: public Symbol operator;
duke@1: protected JCBinary(int opcode,
duke@1: JCExpression lhs,
duke@1: JCExpression rhs,
duke@1: Symbol operator) {
duke@1: this.opcode = opcode;
duke@1: this.lhs = lhs;
duke@1: this.rhs = rhs;
duke@1: this.operator = operator;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitBinary(this); }
duke@1:
duke@1: public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
duke@1: public JCExpression getLeftOperand() { return lhs; }
duke@1: public JCExpression getRightOperand() { return rhs; }
duke@1: public Symbol getOperator() {
duke@1: return operator;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitBinary(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return opcode;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A type cast.
duke@1: */
duke@1: public static class JCTypeCast extends JCExpression implements TypeCastTree {
duke@1: public JCTree clazz;
duke@1: public JCExpression expr;
duke@1: protected JCTypeCast(JCTree clazz, JCExpression expr) {
duke@1: this.clazz = clazz;
duke@1: this.expr = expr;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTypeCast(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.TYPE_CAST; }
duke@1: public JCTree getType() { return clazz; }
duke@1: public JCExpression getExpression() { return expr; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitTypeCast(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TYPECAST;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A type test.
duke@1: */
duke@1: public static class JCInstanceOf extends JCExpression implements InstanceOfTree {
duke@1: public JCExpression expr;
duke@1: public JCTree clazz;
duke@1: protected JCInstanceOf(JCExpression expr, JCTree clazz) {
duke@1: this.expr = expr;
duke@1: this.clazz = clazz;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTypeTest(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.INSTANCE_OF; }
duke@1: public JCTree getType() { return clazz; }
duke@1: public JCExpression getExpression() { return expr; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitInstanceOf(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TYPETEST;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * An array selection
duke@1: */
duke@1: public static class JCArrayAccess extends JCExpression implements ArrayAccessTree {
duke@1: public JCExpression indexed;
duke@1: public JCExpression index;
duke@1: protected JCArrayAccess(JCExpression indexed, JCExpression index) {
duke@1: this.indexed = indexed;
duke@1: this.index = index;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitIndexed(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.ARRAY_ACCESS; }
duke@1: public JCExpression getExpression() { return indexed; }
duke@1: public JCExpression getIndex() { return index; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitArrayAccess(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return INDEXED;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * Selects through packages and classes
duke@1: * @param selected selected Tree hierarchie
duke@1: * @param selector name of field to select thru
duke@1: * @param sym symbol of the selected class
duke@1: */
duke@1: public static class JCFieldAccess extends JCExpression implements MemberSelectTree {
duke@1: public JCExpression selected;
duke@1: public Name name;
duke@1: public Symbol sym;
duke@1: protected JCFieldAccess(JCExpression selected, Name name, Symbol sym) {
duke@1: this.selected = selected;
duke@1: this.name = name;
duke@1: this.sym = sym;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitSelect(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.MEMBER_SELECT; }
duke@1: public JCExpression getExpression() { return selected; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitMemberSelect(this, d);
duke@1: }
duke@1: public Name getIdentifier() { return name; }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return SELECT;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * An identifier
duke@1: * @param idname the name
duke@1: * @param sym the symbol
duke@1: */
duke@1: public static class JCIdent extends JCExpression implements IdentifierTree {
duke@1: public Name name;
duke@1: public Symbol sym;
duke@1: protected JCIdent(Name name, Symbol sym) {
duke@1: this.name = name;
duke@1: this.sym = sym;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitIdent(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.IDENTIFIER; }
duke@1: public Name getName() { return name; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitIdentifier(this, d);
duke@1: }
duke@1: public int getTag() {
duke@1: return IDENT;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A constant value given literally.
duke@1: * @param value value representation
duke@1: */
duke@1: public static class JCLiteral extends JCExpression implements LiteralTree {
duke@1: public int typetag;
duke@1: public Object value;
duke@1: protected JCLiteral(int typetag, Object value) {
duke@1: this.typetag = typetag;
duke@1: this.value = value;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitLiteral(this); }
duke@1:
duke@1: public Kind getKind() {
duke@1: switch (typetag) {
duke@1: case TypeTags.INT:
duke@1: return Kind.INT_LITERAL;
duke@1: case TypeTags.LONG:
duke@1: return Kind.LONG_LITERAL;
duke@1: case TypeTags.FLOAT:
duke@1: return Kind.FLOAT_LITERAL;
duke@1: case TypeTags.DOUBLE:
duke@1: return Kind.DOUBLE_LITERAL;
duke@1: case TypeTags.BOOLEAN:
duke@1: return Kind.BOOLEAN_LITERAL;
duke@1: case TypeTags.CHAR:
duke@1: return Kind.CHAR_LITERAL;
duke@1: case TypeTags.CLASS:
duke@1: return Kind.STRING_LITERAL;
duke@1: case TypeTags.BOT:
duke@1: return Kind.NULL_LITERAL;
duke@1: default:
duke@1: throw new AssertionError("unknown literal kind " + this);
duke@1: }
duke@1: }
duke@1: public Object getValue() {
duke@1: switch (typetag) {
duke@1: case TypeTags.BOOLEAN:
duke@1: int bi = (Integer) value;
duke@1: return (bi != 0);
duke@1: case TypeTags.CHAR:
duke@1: int ci = (Integer) value;
duke@1: char c = (char) ci;
duke@1: if (c != ci)
duke@1: throw new AssertionError("bad value for char literal");
duke@1: return c;
duke@1: default:
duke@1: return value;
duke@1: }
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitLiteral(this, d);
duke@1: }
duke@1: @Override
duke@1: public JCLiteral setType(Type type) {
duke@1: super.setType(type);
duke@1: return this;
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return LITERAL;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * Identifies a basic type.
duke@1: * @param tag the basic type id
duke@1: * @see TypeTags
duke@1: */
duke@1: public static class JCPrimitiveTypeTree extends JCExpression implements PrimitiveTypeTree {
duke@1: public int typetag;
duke@1: protected JCPrimitiveTypeTree(int typetag) {
duke@1: this.typetag = typetag;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTypeIdent(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.PRIMITIVE_TYPE; }
duke@1: public TypeKind getPrimitiveTypeKind() {
duke@1: switch (typetag) {
duke@1: case TypeTags.BOOLEAN:
duke@1: return TypeKind.BOOLEAN;
duke@1: case TypeTags.BYTE:
duke@1: return TypeKind.BYTE;
duke@1: case TypeTags.SHORT:
duke@1: return TypeKind.SHORT;
duke@1: case TypeTags.INT:
duke@1: return TypeKind.INT;
duke@1: case TypeTags.LONG:
duke@1: return TypeKind.LONG;
duke@1: case TypeTags.CHAR:
duke@1: return TypeKind.CHAR;
duke@1: case TypeTags.FLOAT:
duke@1: return TypeKind.FLOAT;
duke@1: case TypeTags.DOUBLE:
duke@1: return TypeKind.DOUBLE;
duke@1: case TypeTags.VOID:
duke@1: return TypeKind.VOID;
duke@1: default:
duke@1: throw new AssertionError("unknown primitive type " + this);
duke@1: }
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitPrimitiveType(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TYPEIDENT;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * An array type, A[]
duke@1: */
duke@1: public static class JCArrayTypeTree extends JCExpression implements ArrayTypeTree {
duke@1: public JCExpression elemtype;
duke@1: protected JCArrayTypeTree(JCExpression elemtype) {
duke@1: this.elemtype = elemtype;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTypeArray(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.ARRAY_TYPE; }
duke@1: public JCTree getType() { return elemtype; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitArrayType(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TYPEARRAY;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A parameterized type, T<...>
duke@1: */
duke@1: public static class JCTypeApply extends JCExpression implements ParameterizedTypeTree {
duke@1: public JCExpression clazz;
duke@1: public List arguments;
duke@1: protected JCTypeApply(JCExpression clazz, List arguments) {
duke@1: this.clazz = clazz;
duke@1: this.arguments = arguments;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTypeApply(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.PARAMETERIZED_TYPE; }
duke@1: public JCTree getType() { return clazz; }
duke@1: public List getTypeArguments() {
duke@1: return arguments;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitParameterizedType(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TYPEAPPLY;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * A formal class parameter.
duke@1: * @param name name
duke@1: * @param bounds bounds
duke@1: */
duke@1: public static class JCTypeParameter extends JCTree implements TypeParameterTree {
duke@1: public Name name;
duke@1: public List bounds;
duke@1: protected JCTypeParameter(Name name, List bounds) {
duke@1: this.name = name;
duke@1: this.bounds = bounds;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTypeParameter(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.TYPE_PARAMETER; }
duke@1: public Name getName() { return name; }
duke@1: public List getBounds() {
duke@1: return bounds;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitTypeParameter(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TYPEPARAMETER;
duke@1: }
duke@1: }
duke@1:
duke@1: public static class JCWildcard extends JCExpression implements WildcardTree {
duke@1: public TypeBoundKind kind;
duke@1: public JCTree inner;
duke@1: protected JCWildcard(TypeBoundKind kind, JCTree inner) {
duke@1: kind.getClass(); // null-check
duke@1: this.kind = kind;
duke@1: this.inner = inner;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitWildcard(this); }
duke@1:
duke@1: public Kind getKind() {
duke@1: switch (kind.kind) {
duke@1: case UNBOUND:
duke@1: return Kind.UNBOUNDED_WILDCARD;
duke@1: case EXTENDS:
duke@1: return Kind.EXTENDS_WILDCARD;
duke@1: case SUPER:
duke@1: return Kind.SUPER_WILDCARD;
duke@1: default:
duke@1: throw new AssertionError("Unknown wildcard bound " + kind);
duke@1: }
duke@1: }
duke@1: public JCTree getBound() { return inner; }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitWildcard(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return WILDCARD;
duke@1: }
duke@1: }
duke@1:
duke@1: public static class TypeBoundKind extends JCTree {
duke@1: public BoundKind kind;
duke@1: protected TypeBoundKind(BoundKind kind) {
duke@1: this.kind = kind;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitTypeBoundKind(this); }
duke@1:
duke@1: public Kind getKind() {
duke@1: throw new AssertionError("TypeBoundKind is not part of a public API");
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: throw new AssertionError("TypeBoundKind is not part of a public API");
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return TYPEBOUNDKIND;
duke@1: }
duke@1: }
duke@1:
duke@1: public static class JCAnnotation extends JCExpression implements AnnotationTree {
duke@1: public JCTree annotationType;
duke@1: public List args;
duke@1: protected JCAnnotation(JCTree annotationType, List args) {
duke@1: this.annotationType = annotationType;
duke@1: this.args = args;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitAnnotation(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.ANNOTATION; }
duke@1: public JCTree getAnnotationType() { return annotationType; }
duke@1: public List getArguments() {
duke@1: return args;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitAnnotation(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return ANNOTATION;
duke@1: }
duke@1: }
duke@1:
duke@1: public static class JCModifiers extends JCTree implements com.sun.source.tree.ModifiersTree {
duke@1: public long flags;
duke@1: public List annotations;
duke@1: protected JCModifiers(long flags, List annotations) {
duke@1: this.flags = flags;
duke@1: this.annotations = annotations;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitModifiers(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.MODIFIERS; }
duke@1: public Set getFlags() {
duke@1: return Flags.asModifierSet(flags);
duke@1: }
duke@1: public List getAnnotations() {
duke@1: return annotations;
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitModifiers(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return MODIFIERS;
duke@1: }
duke@1: }
duke@1:
duke@1: public static class JCErroneous extends JCExpression
duke@1: implements com.sun.source.tree.ErroneousTree {
duke@1: public List errs;
duke@1: protected JCErroneous(List errs) {
duke@1: this.errs = errs;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitErroneous(this); }
duke@1:
duke@1: public Kind getKind() { return Kind.ERRONEOUS; }
duke@1:
duke@1: public List getErrorTrees() {
duke@1: return errs;
duke@1: }
duke@1:
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: return v.visitErroneous(this, d);
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return ERRONEOUS;
duke@1: }
duke@1: }
duke@1:
duke@1: /** (let int x = 3; in x+2) */
duke@1: public static class LetExpr extends JCExpression {
duke@1: public List defs;
duke@1: public JCTree expr;
duke@1: protected LetExpr(List defs, JCTree expr) {
duke@1: this.defs = defs;
duke@1: this.expr = expr;
duke@1: }
duke@1: @Override
duke@1: public void accept(Visitor v) { v.visitLetExpr(this); }
duke@1:
duke@1: public Kind getKind() {
duke@1: throw new AssertionError("LetExpr is not part of a public API");
duke@1: }
duke@1: @Override
duke@1: public R accept(TreeVisitor v, D d) {
duke@1: throw new AssertionError("LetExpr is not part of a public API");
duke@1: }
duke@1: @Override
duke@1: public int getTag() {
duke@1: return LETEXPR;
duke@1: }
duke@1: }
duke@1:
duke@1: /** An interface for tree factories
duke@1: */
duke@1: public interface Factory {
duke@1: JCCompilationUnit TopLevel(List packageAnnotations,
duke@1: JCExpression pid,
duke@1: List defs);
duke@1: JCImport Import(JCTree qualid, boolean staticImport);
duke@1: JCClassDecl ClassDef(JCModifiers mods,
duke@1: Name name,
duke@1: List typarams,
duke@1: JCTree extending,
duke@1: List implementing,
duke@1: List defs);
duke@1: 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,
duke@1: JCExpression defaultValue);
duke@1: JCVariableDecl VarDef(JCModifiers mods,
duke@1: Name name,
duke@1: JCExpression vartype,
duke@1: JCExpression init);
duke@1: JCSkip Skip();
duke@1: JCBlock Block(long flags, List stats);
duke@1: JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);
duke@1: JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);
duke@1: JCForLoop ForLoop(List init,
duke@1: JCExpression cond,
duke@1: List step,
duke@1: JCStatement body);
duke@1: JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
duke@1: JCLabeledStatement Labelled(Name label, JCStatement body);
duke@1: JCSwitch Switch(JCExpression selector, List cases);
duke@1: JCCase Case(JCExpression pat, List stats);
duke@1: JCSynchronized Synchronized(JCExpression lock, JCBlock body);
duke@1: JCTry Try(JCBlock body, List catchers, JCBlock finalizer);
duke@1: JCCatch Catch(JCVariableDecl param, JCBlock body);
duke@1: JCConditional Conditional(JCExpression cond,
duke@1: JCExpression thenpart,
duke@1: JCExpression elsepart);
duke@1: JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
duke@1: JCExpressionStatement Exec(JCExpression expr);
duke@1: JCBreak Break(Name label);
duke@1: JCContinue Continue(Name label);
duke@1: JCReturn Return(JCExpression expr);
duke@1: JCThrow Throw(JCTree expr);
duke@1: JCAssert Assert(JCExpression cond, JCExpression detail);
duke@1: JCMethodInvocation Apply(List typeargs,
duke@1: JCExpression fn,
duke@1: List args);
duke@1: JCNewClass NewClass(JCExpression encl,
duke@1: List typeargs,
duke@1: JCExpression clazz,
duke@1: List args,
duke@1: JCClassDecl def);
duke@1: JCNewArray NewArray(JCExpression elemtype,
duke@1: List dims,
duke@1: List elems);
duke@1: JCParens Parens(JCExpression expr);
duke@1: JCAssign Assign(JCExpression lhs, JCExpression rhs);
duke@1: JCAssignOp Assignop(int opcode, JCTree lhs, JCTree rhs);
duke@1: JCUnary Unary(int opcode, JCExpression arg);
duke@1: JCBinary Binary(int opcode, JCExpression lhs, JCExpression rhs);
duke@1: JCTypeCast TypeCast(JCTree expr, JCExpression type);
duke@1: JCInstanceOf TypeTest(JCExpression expr, JCTree clazz);
duke@1: JCArrayAccess Indexed(JCExpression indexed, JCExpression index);
duke@1: JCFieldAccess Select(JCExpression selected, Name selector);
duke@1: JCIdent Ident(Name idname);
duke@1: JCLiteral Literal(int tag, Object value);
duke@1: JCPrimitiveTypeTree TypeIdent(int typetag);
duke@1: JCArrayTypeTree TypeArray(JCExpression elemtype);
duke@1: JCTypeApply TypeApply(JCExpression clazz, List arguments);
duke@1: JCTypeParameter TypeParameter(Name name, List bounds);
duke@1: JCWildcard Wildcard(TypeBoundKind kind, JCTree type);
duke@1: TypeBoundKind TypeBoundKind(BoundKind kind);
duke@1: JCAnnotation Annotation(JCTree annotationType, List args);
duke@1: JCModifiers Modifiers(long flags, List annotations);
duke@1: JCErroneous Erroneous(List errs);
duke@1: LetExpr LetExpr(List defs, JCTree expr);
duke@1: }
duke@1:
duke@1: /** A generic visitor class for trees.
duke@1: */
duke@1: public static abstract class Visitor {
duke@1: public void visitTopLevel(JCCompilationUnit that) { visitTree(that); }
duke@1: public void visitImport(JCImport that) { visitTree(that); }
duke@1: public void visitClassDef(JCClassDecl that) { visitTree(that); }
duke@1: public void visitMethodDef(JCMethodDecl that) { visitTree(that); }
duke@1: public void visitVarDef(JCVariableDecl that) { visitTree(that); }
duke@1: public void visitSkip(JCSkip that) { visitTree(that); }
duke@1: public void visitBlock(JCBlock that) { visitTree(that); }
duke@1: public void visitDoLoop(JCDoWhileLoop that) { visitTree(that); }
duke@1: public void visitWhileLoop(JCWhileLoop that) { visitTree(that); }
duke@1: public void visitForLoop(JCForLoop that) { visitTree(that); }
duke@1: public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
duke@1: public void visitLabelled(JCLabeledStatement that) { visitTree(that); }
duke@1: public void visitSwitch(JCSwitch that) { visitTree(that); }
duke@1: public void visitCase(JCCase that) { visitTree(that); }
duke@1: public void visitSynchronized(JCSynchronized that) { visitTree(that); }
duke@1: public void visitTry(JCTry that) { visitTree(that); }
duke@1: public void visitCatch(JCCatch that) { visitTree(that); }
duke@1: public void visitConditional(JCConditional that) { visitTree(that); }
duke@1: public void visitIf(JCIf that) { visitTree(that); }
duke@1: public void visitExec(JCExpressionStatement that) { visitTree(that); }
duke@1: public void visitBreak(JCBreak that) { visitTree(that); }
duke@1: public void visitContinue(JCContinue that) { visitTree(that); }
duke@1: public void visitReturn(JCReturn that) { visitTree(that); }
duke@1: public void visitThrow(JCThrow that) { visitTree(that); }
duke@1: public void visitAssert(JCAssert that) { visitTree(that); }
duke@1: public void visitApply(JCMethodInvocation that) { visitTree(that); }
duke@1: public void visitNewClass(JCNewClass that) { visitTree(that); }
duke@1: public void visitNewArray(JCNewArray that) { visitTree(that); }
duke@1: public void visitParens(JCParens that) { visitTree(that); }
duke@1: public void visitAssign(JCAssign that) { visitTree(that); }
duke@1: public void visitAssignop(JCAssignOp that) { visitTree(that); }
duke@1: public void visitUnary(JCUnary that) { visitTree(that); }
duke@1: public void visitBinary(JCBinary that) { visitTree(that); }
duke@1: public void visitTypeCast(JCTypeCast that) { visitTree(that); }
duke@1: public void visitTypeTest(JCInstanceOf that) { visitTree(that); }
duke@1: public void visitIndexed(JCArrayAccess that) { visitTree(that); }
duke@1: public void visitSelect(JCFieldAccess that) { visitTree(that); }
duke@1: public void visitIdent(JCIdent that) { visitTree(that); }
duke@1: public void visitLiteral(JCLiteral that) { visitTree(that); }
duke@1: public void visitTypeIdent(JCPrimitiveTypeTree that) { visitTree(that); }
duke@1: public void visitTypeArray(JCArrayTypeTree that) { visitTree(that); }
duke@1: public void visitTypeApply(JCTypeApply that) { visitTree(that); }
duke@1: public void visitTypeParameter(JCTypeParameter that) { visitTree(that); }
duke@1: public void visitWildcard(JCWildcard that) { visitTree(that); }
duke@1: public void visitTypeBoundKind(TypeBoundKind that) { visitTree(that); }
duke@1: public void visitAnnotation(JCAnnotation that) { visitTree(that); }
duke@1: public void visitModifiers(JCModifiers that) { visitTree(that); }
duke@1: public void visitErroneous(JCErroneous that) { visitTree(that); }
duke@1: public void visitLetExpr(LetExpr that) { visitTree(that); }
duke@1:
duke@1: public void visitTree(JCTree that) { assert false; }
duke@1: }
duke@1:
duke@1: }