jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/tree/JCTree.java@5c9cdeb740f2

6717241: some diagnostic argument is prematurely converted into a String object
Summary: removed early toString() conversions applied to diagnostic arguments
Reviewed-by: jjg

     1 /*

     2  * Copyright 1999-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    26 package com.sun.tools.javac.tree;

    28 import java.util.*;

    30 import java.io.File;

    31 import java.io.IOException;

    32 import java.io.PrintWriter;

    33 import java.io.StringWriter;

    34 import javax.lang.model.element.Modifier;

    35 import javax.lang.model.type.TypeKind;

    36 import javax.tools.JavaFileObject;

    38 import com.sun.tools.javac.util.*;

    39 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

    40 import com.sun.tools.javac.util.List;

    41 import com.sun.tools.javac.code.*;

    42 import com.sun.tools.javac.code.Scope;

    43 import com.sun.tools.javac.code.Symbol.*;

    44 import com.sun.source.tree.Tree;

    45 import com.sun.source.tree.*;

    47 import static com.sun.tools.javac.code.BoundKind.*;

    49 /**

    50  * Root class for abstract syntax tree nodes. It provides definitions

    51  * for specific tree nodes as subclasses nested inside.

    52  *

    53  * <p>Each subclass is highly standardized.  It generally contains

    54  * only tree fields for the syntactic subcomponents of the node.  Some

    55  * classes that represent identifier uses or definitions also define a

    56  * Symbol field that denotes the represented identifier.  Classes for

    57  * non-local jumps also carry the jump target as a field.  The root

    58  * class Tree itself defines fields for the tree's type and position.

    59  * No other fields are kept in a tree node; instead parameters are

    60  * passed to methods accessing the node.

    61  *

    62  * <p>Except for the methods defined by com.sun.source, the only

    63  * method defined in subclasses is `visit' which applies a given

    64  * visitor to the tree. The actual tree processing is done by visitor

    65  * classes in other packages. The abstract class Visitor, as well as

    66  * an Factory interface for trees, are defined as inner classes in

    67  * Tree.

    68  *

    69  * <p>To avoid ambiguities with the Tree API in com.sun.source all sub

    70  * classes should, by convention, start with JC (javac).

    71  *

    72  * <p><b>This is NOT part of any API supported by Sun Microsystems.

    73  * If you write code that depends on this, you do so at your own risk.

    74  * This code and its internal interfaces are subject to change or

    75  * deletion without notice.</b>

    76  *

    77  * @see TreeMaker

    78  * @see TreeInfo

    79  * @see TreeTranslator

    80  * @see Pretty

    81  */

    82 public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {

    84     /* Tree tag values, identifying kinds of trees */

    86     /** Toplevel nodes, of type TopLevel, representing entire source files.

    87      */

    88     public static final int  TOPLEVEL = 1;

    90     /** Import clauses, of type Import.

    91      */

    92     public static final int IMPORT = TOPLEVEL + 1;

    94     /** Class definitions, of type ClassDef.

    95      */

    96     public static final int CLASSDEF = IMPORT + 1;

    98     /** Method definitions, of type MethodDef.

    99      */

   100     public static final int METHODDEF = CLASSDEF + 1;

   102     /** Variable definitions, of type VarDef.

   103      */

   104     public static final int VARDEF = METHODDEF + 1;

   106     /** The no-op statement ";", of type Skip

   107      */

   108     public static final int SKIP = VARDEF + 1;

   110     /** Blocks, of type Block.

   111      */

   112     public static final int BLOCK = SKIP + 1;

   114     /** Do-while loops, of type DoLoop.

   115      */

   116     public static final int DOLOOP = BLOCK + 1;

   118     /** While-loops, of type WhileLoop.

   119      */

   120     public static final int WHILELOOP = DOLOOP + 1;

   122     /** For-loops, of type ForLoop.

   123      */

   124     public static final int FORLOOP = WHILELOOP + 1;

   126     /** Foreach-loops, of type ForeachLoop.

   127      */

   128     public static final int FOREACHLOOP = FORLOOP + 1;

   130     /** Labelled statements, of type Labelled.

   131      */

   132     public static final int LABELLED = FOREACHLOOP + 1;

   134     /** Switch statements, of type Switch.

   135      */

   136     public static final int SWITCH = LABELLED + 1;

   138     /** Case parts in switch statements, of type Case.

   139      */

   140     public static final int CASE = SWITCH + 1;

   142     /** Synchronized statements, of type Synchonized.

   143      */

   144     public static final int SYNCHRONIZED = CASE + 1;

   146     /** Try statements, of type Try.

   147      */

   148     public static final int TRY = SYNCHRONIZED + 1;

   150     /** Catch clauses in try statements, of type Catch.

   151      */

   152     public static final int CATCH = TRY + 1;

   154     /** Conditional expressions, of type Conditional.

   155      */

   156     public static final int CONDEXPR = CATCH + 1;

   158     /** Conditional statements, of type If.

   159      */

   160     public static final int IF = CONDEXPR + 1;

   162     /** Expression statements, of type Exec.

   163      */

   164     public static final int EXEC = IF + 1;

   166     /** Break statements, of type Break.

   167      */

   168     public static final int BREAK = EXEC + 1;

   170     /** Continue statements, of type Continue.

   171      */

   172     public static final int CONTINUE = BREAK + 1;

   174     /** Return statements, of type Return.

   175      */

   176     public static final int RETURN = CONTINUE + 1;

   178     /** Throw statements, of type Throw.

   179      */

   180     public static final int THROW = RETURN + 1;

   182     /** Assert statements, of type Assert.

   183      */

   184     public static final int ASSERT = THROW + 1;

   186     /** Method invocation expressions, of type Apply.

   187      */

   188     public static final int APPLY = ASSERT + 1;

   190     /** Class instance creation expressions, of type NewClass.

   191      */

   192     public static final int NEWCLASS = APPLY + 1;

   194     /** Array creation expressions, of type NewArray.

   195      */

   196     public static final int NEWARRAY = NEWCLASS + 1;

   198     /** Parenthesized subexpressions, of type Parens.

   199      */

   200     public static final int PARENS = NEWARRAY + 1;

   202     /** Assignment expressions, of type Assign.

   203      */

   204     public static final int ASSIGN = PARENS + 1;

   206     /** Type cast expressions, of type TypeCast.

   207      */

   208     public static final int TYPECAST = ASSIGN + 1;

   210     /** Type test expressions, of type TypeTest.

   211      */

   212     public static final int TYPETEST = TYPECAST + 1;

   214     /** Indexed array expressions, of type Indexed.

   215      */

   216     public static final int INDEXED = TYPETEST + 1;

   218     /** Selections, of type Select.

   219      */

   220     public static final int SELECT = INDEXED + 1;

   222     /** Simple identifiers, of type Ident.

   223      */

   224     public static final int IDENT = SELECT + 1;

   226     /** Literals, of type Literal.

   227      */

   228     public static final int LITERAL = IDENT + 1;

   230     /** Basic type identifiers, of type TypeIdent.

   231      */

   232     public static final int TYPEIDENT = LITERAL + 1;

   234     /** Array types, of type TypeArray.

   235      */

   236     public static final int TYPEARRAY = TYPEIDENT + 1;

   238     /** Parameterized types, of type TypeApply.

   239      */

   240     public static final int TYPEAPPLY = TYPEARRAY + 1;

   242     /** Formal type parameters, of type TypeParameter.

   243      */

   244     public static final int TYPEPARAMETER = TYPEAPPLY + 1;

   246     /** Type argument.

   247      */

   248     public static final int WILDCARD = TYPEPARAMETER + 1;

   250     /** Bound kind: extends, super, exact, or unbound

   251      */

   252     public static final int TYPEBOUNDKIND = WILDCARD + 1;

   254     /** metadata: Annotation.

   255      */

   256     public static final int ANNOTATION = TYPEBOUNDKIND + 1;

   258     /** metadata: Modifiers

   259      */

   260     public static final int MODIFIERS = ANNOTATION + 1;

   262     /** Error trees, of type Erroneous.

   263      */

   264     public static final int ERRONEOUS = MODIFIERS + 1;

   266     /** Unary operators, of type Unary.

   267      */

   268     public static final int POS = ERRONEOUS + 1;             // +

   269     public static final int NEG = POS + 1;                   // -

   270     public static final int NOT = NEG + 1;                   // !

   271     public static final int COMPL = NOT + 1;                 // ~

   272     public static final int PREINC = COMPL + 1;              // ++ _

   273     public static final int PREDEC = PREINC + 1;             // -- _

   274     public static final int POSTINC = PREDEC + 1;            // _ ++

   275     public static final int POSTDEC = POSTINC + 1;           // _ --

   277     /** unary operator for null reference checks, only used internally.

   278      */

   279     public static final int NULLCHK = POSTDEC + 1;

   281     /** Binary operators, of type Binary.

   282      */

   283     public static final int OR = NULLCHK + 1;                // ||

   284     public static final int AND = OR + 1;                    // &&

   285     public static final int BITOR = AND + 1;                 // |

   286     public static final int BITXOR = BITOR + 1;              // ^

   287     public static final int BITAND = BITXOR + 1;             // &

   288     public static final int EQ = BITAND + 1;                 // ==

   289     public static final int NE = EQ + 1;                     // !=

   290     public static final int LT = NE + 1;                     // <

   291     public static final int GT = LT + 1;                     // >

   292     public static final int LE = GT + 1;                     // <=

   293     public static final int GE = LE + 1;                     // >=

   294     public static final int SL = GE + 1;                     // <<

   295     public static final int SR = SL + 1;                     // >>

   296     public static final int USR = SR + 1;                    // >>>

   297     public static final int PLUS = USR + 1;                  // +

   298     public static final int MINUS = PLUS + 1;                // -

   299     public static final int MUL = MINUS + 1;                 // *

   300     public static final int DIV = MUL + 1;                   // /

   301     public static final int MOD = DIV + 1;                   // %

   303     /** Assignment operators, of type Assignop.

   304      */

   305     public static final int BITOR_ASG = MOD + 1;             // |=

   306     public static final int BITXOR_ASG = BITOR_ASG + 1;      // ^=

   307     public static final int BITAND_ASG = BITXOR_ASG + 1;     // &=

   309     public static final int SL_ASG = SL + BITOR_ASG - BITOR; // <<=

   310     public static final int SR_ASG = SL_ASG + 1;             // >>=

   311     public static final int USR_ASG = SR_ASG + 1;            // >>>=

   312     public static final int PLUS_ASG = USR_ASG + 1;          // +=

   313     public static final int MINUS_ASG = PLUS_ASG + 1;        // -=

   314     public static final int MUL_ASG = MINUS_ASG + 1;         // *=

   315     public static final int DIV_ASG = MUL_ASG + 1;           // /=

   316     public static final int MOD_ASG = DIV_ASG + 1;           // %=

   318     /** A synthetic let expression, of type LetExpr.

   319      */

   320     public static final int LETEXPR = MOD_ASG + 1;           // ala scheme

   323     /** The offset between assignment operators and normal operators.

   324      */

   325     public static final int ASGOffset = BITOR_ASG - BITOR;

   327     /* The (encoded) position in the source file. @see util.Position.

   328      */

   329     public int pos;

   331     /* The type of this node.

   332      */

   333     public Type type;

   335     /* The tag of this node -- one of the constants declared above.

   336      */

   337     public abstract int getTag();

   339     /** Convert a tree to a pretty-printed string. */

   340     public String toString() {

   341         StringWriter s = new StringWriter();

   342         try {

   343             new Pretty(s, false).printExpr(this);

   344         }

   345         catch (IOException e) {

   346             // should never happen, because StringWriter is defined

   347             // never to throw any IOExceptions

   348             throw new AssertionError(e);

   349         }

   350         return s.toString();

   351     }

   353     /** Set position field and return this tree.

   354      */

   355     public JCTree setPos(int pos) {

   356         this.pos = pos;

   357         return this;

   358     }

   360     /** Set type field and return this tree.

   361      */

   362     public JCTree setType(Type type) {

   363         this.type = type;

   364         return this;

   365     }

   367     /** Visit this tree with a given visitor.

   368      */

   369     public abstract void accept(Visitor v);

   371     public abstract <R,D> R accept(TreeVisitor<R,D> v, D d);

   373     /** Return a shallow copy of this tree.

   374      */

   375     public Object clone() {

   376         try {

   377             return super.clone();

   378         } catch(CloneNotSupportedException e) {

   379             throw new RuntimeException(e);

   380         }

   381     }

   383     /** Get a default position for this tree node.

   384      */

   385     public DiagnosticPosition pos() {

   386         return this;

   387     }

   389     // for default DiagnosticPosition

   390     public JCTree getTree() {

   391         return this;

   392     }

   394     // for default DiagnosticPosition

   395     public int getStartPosition() {

   396         return TreeInfo.getStartPos(this);

   397     }

   399     // for default DiagnosticPosition

   400     public int getPreferredPosition() {

   401         return pos;

   402     }

   404     // for default DiagnosticPosition

   405     public int getEndPosition(Map<JCTree, Integer> endPosTable) {

   406         return TreeInfo.getEndPos(this, endPosTable);

   407     }

   409     /**

   410      * Everything in one source file is kept in a TopLevel structure.

   411      * @param pid              The tree representing the package clause.

   412      * @param sourcefile       The source file name.

   413      * @param defs             All definitions in this file (ClassDef, Import, and Skip)

   414      * @param packge           The package it belongs to.

   415      * @param namedImportScope A scope for all named imports.

   416      * @param starImportScope  A scope for all import-on-demands.

   417      * @param lineMap          Line starting positions, defined only

   418      *                         if option -g is set.

   419      * @param docComments      A hashtable that stores all documentation comments

   420      *                         indexed by the tree nodes they refer to.

   421      *                         defined only if option -s is set.

   422      * @param endPositions     A hashtable that stores ending positions of source

   423      *                         ranges indexed by the tree nodes they belong to.

   424      *                         Defined only if option -Xjcov is set.

   425      */

   426     public static class JCCompilationUnit extends JCTree implements CompilationUnitTree {

   427         public List<JCAnnotation> packageAnnotations;

   428         public JCExpression pid;

   429         public List<JCTree> defs;

   430         public JavaFileObject sourcefile;

   431         public PackageSymbol packge;

   432         public Scope namedImportScope;

   433         public Scope starImportScope;

   434         public long flags;

   435         public Position.LineMap lineMap = null;

   436         public Map<JCTree, String> docComments = null;

   437         public Map<JCTree, Integer> endPositions = null;

   438         protected JCCompilationUnit(List<JCAnnotation> packageAnnotations,

   439                         JCExpression pid,

   440                         List<JCTree> defs,

   441                         JavaFileObject sourcefile,

   442                         PackageSymbol packge,

   443                         Scope namedImportScope,

   444                         Scope starImportScope) {

   445             this.packageAnnotations = packageAnnotations;

   446             this.pid = pid;

   447             this.defs = defs;

   448             this.sourcefile = sourcefile;

   449             this.packge = packge;

   450             this.namedImportScope = namedImportScope;

   451             this.starImportScope = starImportScope;

   452         }

   453         @Override

   454         public void accept(Visitor v) { v.visitTopLevel(this); }

   456         public Kind getKind() { return Kind.COMPILATION_UNIT; }

   457         public List<JCAnnotation> getPackageAnnotations() {

   458             return packageAnnotations;

   459         }

   460         public List<JCImport> getImports() {

   461             ListBuffer<JCImport> imports = new ListBuffer<JCImport>();

   462             for (JCTree tree : defs) {

   463                 if (tree.getTag() == IMPORT)

   464                     imports.append((JCImport)tree);

   465                 else

   466                     break;

   467             }

   468             return imports.toList();

   469         }

   470         public JCExpression getPackageName() { return pid; }

   471         public JavaFileObject getSourceFile() {

   472             return sourcefile;

   473         }

   474         public Position.LineMap getLineMap() {

   475             return lineMap;

   476         }

   477         public List<JCTree> getTypeDecls() {

   478             List<JCTree> typeDefs;

   479             for (typeDefs = defs; !typeDefs.isEmpty(); typeDefs = typeDefs.tail)

   480                 if (typeDefs.head.getTag() != IMPORT)

   481                     break;

   482             return typeDefs;

   483         }

   484         @Override

   485         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   486             return v.visitCompilationUnit(this, d);

   487         }

   489         @Override

   490         public int getTag() {

   491             return TOPLEVEL;

   492         }

   493     }

   495     /**

   496      * An import clause.

   497      * @param qualid    The imported class(es).

   498      */

   499     public static class JCImport extends JCTree implements ImportTree {

   500         public boolean staticImport;

   501         public JCTree qualid;

   502         protected JCImport(JCTree qualid, boolean importStatic) {

   503             this.qualid = qualid;

   504             this.staticImport = importStatic;

   505         }

   506         @Override

   507         public void accept(Visitor v) { v.visitImport(this); }

   509         public boolean isStatic() { return staticImport; }

   510         public JCTree getQualifiedIdentifier() { return qualid; }

   512         public Kind getKind() { return Kind.IMPORT; }

   513         @Override

   514         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   515             return v.visitImport(this, d);

   516         }

   518         @Override

   519         public int getTag() {

   520             return IMPORT;

   521         }

   522     }

   524     public static abstract class JCStatement extends JCTree implements StatementTree {

   525         @Override

   526         public JCStatement setType(Type type) {

   527             super.setType(type);

   528             return this;

   529         }

   530         @Override

   531         public JCStatement setPos(int pos) {

   532             super.setPos(pos);

   533             return this;

   534         }

   535     }

   537     public static abstract class JCExpression extends JCTree implements ExpressionTree {

   538         @Override

   539         public JCExpression setType(Type type) {

   540             super.setType(type);

   541             return this;

   542         }

   543         @Override

   544         public JCExpression setPos(int pos) {

   545             super.setPos(pos);

   546             return this;

   547         }

   548     }

   550     /**

   551      * A class definition.

   552      * @param modifiers the modifiers

   553      * @param name the name of the class

   554      * @param typarams formal class parameters

   555      * @param extending the classes this class extends

   556      * @param implementing the interfaces implemented by this class

   557      * @param defs all variables and methods defined in this class

   558      * @param sym the symbol

   559      */

   560     public static class JCClassDecl extends JCStatement implements ClassTree {

   561         public JCModifiers mods;

   562         public Name name;

   563         public List<JCTypeParameter> typarams;

   564         public JCTree extending;

   565         public List<JCExpression> implementing;

   566         public List<JCTree> defs;

   567         public ClassSymbol sym;

   568         protected JCClassDecl(JCModifiers mods,

   569                            Name name,

   570                            List<JCTypeParameter> typarams,

   571                            JCTree extending,

   572                            List<JCExpression> implementing,

   573                            List<JCTree> defs,

   574                            ClassSymbol sym)

   575         {

   576             this.mods = mods;

   577             this.name = name;

   578             this.typarams = typarams;

   579             this.extending = extending;

   580             this.implementing = implementing;

   581             this.defs = defs;

   582             this.sym = sym;

   583         }

   584         @Override

   585         public void accept(Visitor v) { v.visitClassDef(this); }

   587         public Kind getKind() { return Kind.CLASS; }

   588         public JCModifiers getModifiers() { return mods; }

   589         public Name getSimpleName() { return name; }

   590         public List<JCTypeParameter> getTypeParameters() {

   591             return typarams;

   592         }

   593         public JCTree getExtendsClause() { return extending; }

   594         public List<JCExpression> getImplementsClause() {

   595             return implementing;

   596         }

   597         public List<JCTree> getMembers() {

   598             return defs;

   599         }

   600         @Override

   601         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   602             return v.visitClass(this, d);

   603         }

   605         @Override

   606         public int getTag() {

   607             return CLASSDEF;

   608         }

   609     }

   611     /**

   612      * A method definition.

   613      * @param modifiers method modifiers

   614      * @param name method name

   615      * @param restype type of method return value

   616      * @param typarams type parameters

   617      * @param params value parameters

   618      * @param thrown exceptions thrown by this method

   619      * @param stats statements in the method

   620      * @param sym method symbol

   621      */

   622     public static class JCMethodDecl extends JCTree implements MethodTree {

   623         public JCModifiers mods;

   624         public Name name;

   625         public JCExpression restype;

   626         public List<JCTypeParameter> typarams;

   627         public List<JCVariableDecl> params;

   628         public List<JCExpression> thrown;

   629         public JCBlock body;

   630         public JCExpression defaultValue; // for annotation types

   631         public MethodSymbol sym;

   632         protected JCMethodDecl(JCModifiers mods,

   633                             Name name,

   634                             JCExpression restype,

   635                             List<JCTypeParameter> typarams,

   636                             List<JCVariableDecl> params,

   637                             List<JCExpression> thrown,

   638                             JCBlock body,

   639                             JCExpression defaultValue,

   640                             MethodSymbol sym)

   641         {

   642             this.mods = mods;

   643             this.name = name;

   644             this.restype = restype;

   645             this.typarams = typarams;

   646             this.params = params;

   647             this.thrown = thrown;

   648             this.body = body;

   649             this.defaultValue = defaultValue;

   650             this.sym = sym;

   651         }

   652         @Override

   653         public void accept(Visitor v) { v.visitMethodDef(this); }

   655         public Kind getKind() { return Kind.METHOD; }

   656         public JCModifiers getModifiers() { return mods; }

   657         public Name getName() { return name; }

   658         public JCTree getReturnType() { return restype; }

   659         public List<JCTypeParameter> getTypeParameters() {

   660             return typarams;

   661         }

   662         public List<JCVariableDecl> getParameters() {

   663             return params;

   664         }

   665         public List<JCExpression> getThrows() {

   666             return thrown;

   667         }

   668         public JCBlock getBody() { return body; }

   669         public JCTree getDefaultValue() { // for annotation types

   670             return defaultValue;

   671         }

   672         @Override

   673         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   674             return v.visitMethod(this, d);

   675         }

   677         @Override

   678         public int getTag() {

   679             return METHODDEF;

   680         }

   681   }

   683     /**

   684      * A variable definition.

   685      * @param modifiers variable modifiers

   686      * @param name variable name

   687      * @param vartype type of the variable

   688      * @param init variables initial value

   689      * @param sym symbol

   690      */

   691     public static class JCVariableDecl extends JCStatement implements VariableTree {

   692         public JCModifiers mods;

   693         public Name name;

   694         public JCExpression vartype;

   695         public JCExpression init;

   696         public VarSymbol sym;

   697         protected JCVariableDecl(JCModifiers mods,

   698                          Name name,

   699                          JCExpression vartype,

   700                          JCExpression init,

   701                          VarSymbol sym) {

   702             this.mods = mods;

   703             this.name = name;

   704             this.vartype = vartype;

   705             this.init = init;

   706             this.sym = sym;

   707         }

   708         @Override

   709         public void accept(Visitor v) { v.visitVarDef(this); }

   711         public Kind getKind() { return Kind.VARIABLE; }

   712         public JCModifiers getModifiers() { return mods; }

   713         public Name getName() { return name; }

   714         public JCTree getType() { return vartype; }

   715         public JCExpression getInitializer() {

   716             return init;

   717         }

   718         @Override

   719         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   720             return v.visitVariable(this, d);

   721         }

   723         @Override

   724         public int getTag() {

   725             return VARDEF;

   726         }

   727     }

   729       /**

   730      * A no-op statement ";".

   731      */

   732     public static class JCSkip extends JCStatement implements EmptyStatementTree {

   733         protected JCSkip() {

   734         }

   735         @Override

   736         public void accept(Visitor v) { v.visitSkip(this); }

   738         public Kind getKind() { return Kind.EMPTY_STATEMENT; }

   739         @Override

   740         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   741             return v.visitEmptyStatement(this, d);

   742         }

   744         @Override

   745         public int getTag() {

   746             return SKIP;

   747         }

   748     }

   750     /**

   751      * A statement block.

   752      * @param stats statements

   753      * @param flags flags

   754      */

   755     public static class JCBlock extends JCStatement implements BlockTree {

   756         public long flags;

   757         public List<JCStatement> stats;

   758         /** Position of closing brace, optional. */

   759         public int endpos = Position.NOPOS;

   760         protected JCBlock(long flags, List<JCStatement> stats) {

   761             this.stats = stats;

   762             this.flags = flags;

   763         }

   764         @Override

   765         public void accept(Visitor v) { v.visitBlock(this); }

   767         public Kind getKind() { return Kind.BLOCK; }

   768         public List<JCStatement> getStatements() {

   769             return stats;

   770         }

   771         public boolean isStatic() { return (flags & Flags.STATIC) != 0; }

   772         @Override

   773         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   774             return v.visitBlock(this, d);

   775         }

   777         @Override

   778         public int getTag() {

   779             return BLOCK;

   780         }

   781     }

   783     /**

   784      * A do loop

   785      */

   786     public static class JCDoWhileLoop extends JCStatement implements DoWhileLoopTree {

   787         public JCStatement body;

   788         public JCExpression cond;

   789         protected JCDoWhileLoop(JCStatement body, JCExpression cond) {

   790             this.body = body;

   791             this.cond = cond;

   792         }

   793         @Override

   794         public void accept(Visitor v) { v.visitDoLoop(this); }

   796         public Kind getKind() { return Kind.DO_WHILE_LOOP; }

   797         public JCExpression getCondition() { return cond; }

   798         public JCStatement getStatement() { return body; }

   799         @Override

   800         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   801             return v.visitDoWhileLoop(this, d);

   802         }

   804         @Override

   805         public int getTag() {

   806             return DOLOOP;

   807         }

   808     }

   810     /**

   811      * A while loop

   812      */

   813     public static class JCWhileLoop extends JCStatement implements WhileLoopTree {

   814         public JCExpression cond;

   815         public JCStatement body;

   816         protected JCWhileLoop(JCExpression cond, JCStatement body) {

   817             this.cond = cond;

   818             this.body = body;

   819         }

   820         @Override

   821         public void accept(Visitor v) { v.visitWhileLoop(this); }

   823         public Kind getKind() { return Kind.WHILE_LOOP; }

   824         public JCExpression getCondition() { return cond; }

   825         public JCStatement getStatement() { return body; }

   826         @Override

   827         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   828             return v.visitWhileLoop(this, d);

   829         }

   831         @Override

   832         public int getTag() {

   833             return WHILELOOP;

   834         }

   835     }

   837     /**

   838      * A for loop.

   839      */

   840     public static class JCForLoop extends JCStatement implements ForLoopTree {

   841         public List<JCStatement> init;

   842         public JCExpression cond;

   843         public List<JCExpressionStatement> step;

   844         public JCStatement body;

   845         protected JCForLoop(List<JCStatement> init,

   846                           JCExpression cond,

   847                           List<JCExpressionStatement> update,

   848                           JCStatement body)

   849         {

   850             this.init = init;

   851             this.cond = cond;

   852             this.step = update;

   853             this.body = body;

   854         }

   855         @Override

   856         public void accept(Visitor v) { v.visitForLoop(this); }

   858         public Kind getKind() { return Kind.FOR_LOOP; }

   859         public JCExpression getCondition() { return cond; }

   860         public JCStatement getStatement() { return body; }

   861         public List<JCStatement> getInitializer() {

   862             return init;

   863         }

   864         public List<JCExpressionStatement> getUpdate() {

   865             return step;

   866         }

   867         @Override

   868         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   869             return v.visitForLoop(this, d);

   870         }

   872         @Override

   873         public int getTag() {

   874             return FORLOOP;

   875         }

   876     }

   878     /**

   879      * The enhanced for loop.

   880      */

   881     public static class JCEnhancedForLoop extends JCStatement implements EnhancedForLoopTree {

   882         public JCVariableDecl var;

   883         public JCExpression expr;

   884         public JCStatement body;

   885         protected JCEnhancedForLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {

   886             this.var = var;

   887             this.expr = expr;

   888             this.body = body;

   889         }

   890         @Override

   891         public void accept(Visitor v) { v.visitForeachLoop(this); }

   893         public Kind getKind() { return Kind.ENHANCED_FOR_LOOP; }

   894         public JCVariableDecl getVariable() { return var; }

   895         public JCExpression getExpression() { return expr; }

   896         public JCStatement getStatement() { return body; }

   897         @Override

   898         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   899             return v.visitEnhancedForLoop(this, d);

   900         }

   901         @Override

   902         public int getTag() {

   903             return FOREACHLOOP;

   904         }

   905     }

   907     /**

   908      * A labelled expression or statement.

   909      */

   910     public static class JCLabeledStatement extends JCStatement implements LabeledStatementTree {

   911         public Name label;

   912         public JCStatement body;

   913         protected JCLabeledStatement(Name label, JCStatement body) {

   914             this.label = label;

   915             this.body = body;

   916         }

   917         @Override

   918         public void accept(Visitor v) { v.visitLabelled(this); }

   919         public Kind getKind() { return Kind.LABELED_STATEMENT; }

   920         public Name getLabel() { return label; }

   921         public JCStatement getStatement() { return body; }

   922         @Override

   923         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   924             return v.visitLabeledStatement(this, d);

   925         }

   926         @Override

   927         public int getTag() {

   928             return LABELLED;

   929         }

   930     }

   932     /**

   933      * A "switch ( ) { }" construction.

   934      */

   935     public static class JCSwitch extends JCStatement implements SwitchTree {

   936         public JCExpression selector;

   937         public List<JCCase> cases;

   938         protected JCSwitch(JCExpression selector, List<JCCase> cases) {

   939             this.selector = selector;

   940             this.cases = cases;

   941         }

   942         @Override

   943         public void accept(Visitor v) { v.visitSwitch(this); }

   945         public Kind getKind() { return Kind.SWITCH; }

   946         public JCExpression getExpression() { return selector; }

   947         public List<JCCase> getCases() { return cases; }

   948         @Override

   949         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   950             return v.visitSwitch(this, d);

   951         }

   952         @Override

   953         public int getTag() {

   954             return SWITCH;

   955         }

   956     }

   958     /**

   959      * A "case  :" of a switch.

   960      */

   961     public static class JCCase extends JCStatement implements CaseTree {

   962         public JCExpression pat;

   963         public List<JCStatement> stats;

   964         protected JCCase(JCExpression pat, List<JCStatement> stats) {

   965             this.pat = pat;

   966             this.stats = stats;

   967         }

   968         @Override

   969         public void accept(Visitor v) { v.visitCase(this); }

   971         public Kind getKind() { return Kind.CASE; }

   972         public JCExpression getExpression() { return pat; }

   973         public List<JCStatement> getStatements() { return stats; }

   974         @Override

   975         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

   976             return v.visitCase(this, d);

   977         }

   978         @Override

   979         public int getTag() {

   980             return CASE;

   981         }

   982     }

   984     /**

   985      * A synchronized block.

   986      */

   987     public static class JCSynchronized extends JCStatement implements SynchronizedTree {

   988         public JCExpression lock;

   989         public JCBlock body;

   990         protected JCSynchronized(JCExpression lock, JCBlock body) {

   991             this.lock = lock;

   992             this.body = body;

   993         }

   994         @Override

   995         public void accept(Visitor v) { v.visitSynchronized(this); }

   997         public Kind getKind() { return Kind.SYNCHRONIZED; }

   998         public JCExpression getExpression() { return lock; }

   999         public JCBlock getBlock() { return body; }

  1000         @Override

  1001         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1002             return v.visitSynchronized(this, d);

  1003         }

  1004         @Override

  1005         public int getTag() {

  1006             return SYNCHRONIZED;

  1007         }

  1008     }

  1010     /**

  1011      * A "try { } catch ( ) { } finally { }" block.

  1012      */

  1013     public static class JCTry extends JCStatement implements TryTree {

  1014         public JCBlock body;

  1015         public List<JCCatch> catchers;

  1016         public JCBlock finalizer;

  1017         protected JCTry(JCBlock body, List<JCCatch> catchers, JCBlock finalizer) {

  1018             this.body = body;

  1019             this.catchers = catchers;

  1020             this.finalizer = finalizer;

  1021         }

  1022         @Override

  1023         public void accept(Visitor v) { v.visitTry(this); }

  1025         public Kind getKind() { return Kind.TRY; }

  1026         public JCBlock getBlock() { return body; }

  1027         public List<JCCatch> getCatches() {

  1028             return catchers;

  1029         }

  1030         public JCBlock getFinallyBlock() { return finalizer; }

  1031         @Override

  1032         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1033             return v.visitTry(this, d);

  1034         }

  1035         @Override

  1036         public int getTag() {

  1037             return TRY;

  1038         }

  1039     }

  1041     /**

  1042      * A catch block.

  1043      */

  1044     public static class JCCatch extends JCTree implements CatchTree {

  1045         public JCVariableDecl param;

  1046         public JCBlock body;

  1047         protected JCCatch(JCVariableDecl param, JCBlock body) {

  1048             this.param = param;

  1049             this.body = body;

  1050         }

  1051         @Override

  1052         public void accept(Visitor v) { v.visitCatch(this); }

  1054         public Kind getKind() { return Kind.CATCH; }

  1055         public JCVariableDecl getParameter() { return param; }

  1056         public JCBlock getBlock() { return body; }

  1057         @Override

  1058         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1059             return v.visitCatch(this, d);

  1060         }

  1061         @Override

  1062         public int getTag() {

  1063             return CATCH;

  1064         }

  1065     }

  1067     /**

  1068      * A ( ) ? ( ) : ( ) conditional expression

  1069      */

  1070     public static class JCConditional extends JCExpression implements ConditionalExpressionTree {

  1071         public JCExpression cond;

  1072         public JCExpression truepart;

  1073         public JCExpression falsepart;

  1074         protected JCConditional(JCExpression cond,

  1075                               JCExpression truepart,

  1076                               JCExpression falsepart)

  1077         {

  1078             this.cond = cond;

  1079             this.truepart = truepart;

  1080             this.falsepart = falsepart;

  1081         }

  1082         @Override

  1083         public void accept(Visitor v) { v.visitConditional(this); }

  1085         public Kind getKind() { return Kind.CONDITIONAL_EXPRESSION; }

  1086         public JCExpression getCondition() { return cond; }

  1087         public JCExpression getTrueExpression() { return truepart; }

  1088         public JCExpression getFalseExpression() { return falsepart; }

  1089         @Override

  1090         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1091             return v.visitConditionalExpression(this, d);

  1092         }

  1093         @Override

  1094         public int getTag() {

  1095             return CONDEXPR;

  1096         }

  1097     }

  1099     /**

  1100      * An "if ( ) { } else { }" block

  1101      */

  1102     public static class JCIf extends JCStatement implements IfTree {

  1103         public JCExpression cond;

  1104         public JCStatement thenpart;

  1105         public JCStatement elsepart;

  1106         protected JCIf(JCExpression cond,

  1107                      JCStatement thenpart,

  1108                      JCStatement elsepart)

  1109         {

  1110             this.cond = cond;

  1111             this.thenpart = thenpart;

  1112             this.elsepart = elsepart;

  1113         }

  1114         @Override

  1115         public void accept(Visitor v) { v.visitIf(this); }

  1117         public Kind getKind() { return Kind.IF; }

  1118         public JCExpression getCondition() { return cond; }

  1119         public JCStatement getThenStatement() { return thenpart; }

  1120         public JCStatement getElseStatement() { return elsepart; }

  1121         @Override

  1122         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1123             return v.visitIf(this, d);

  1124         }

  1125         @Override

  1126         public int getTag() {

  1127             return IF;

  1128         }

  1129     }

  1131     /**

  1132      * an expression statement

  1133      * @param expr expression structure

  1134      */

  1135     public static class JCExpressionStatement extends JCStatement implements ExpressionStatementTree {

  1136         public JCExpression expr;

  1137         protected JCExpressionStatement(JCExpression expr)

  1138         {

  1139             this.expr = expr;

  1140         }

  1141         @Override

  1142         public void accept(Visitor v) { v.visitExec(this); }

  1144         public Kind getKind() { return Kind.EXPRESSION_STATEMENT; }

  1145         public JCExpression getExpression() { return expr; }

  1146         @Override

  1147         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1148             return v.visitExpressionStatement(this, d);

  1149         }

  1150         @Override

  1151         public int getTag() {

  1152             return EXEC;

  1153         }

  1154     }

  1156     /**

  1157      * A break from a loop or switch.

  1158      */

  1159     public static class JCBreak extends JCStatement implements BreakTree {

  1160         public Name label;

  1161         public JCTree target;

  1162         protected JCBreak(Name label, JCTree target) {

  1163             this.label = label;

  1164             this.target = target;

  1165         }

  1166         @Override

  1167         public void accept(Visitor v) { v.visitBreak(this); }

  1169         public Kind getKind() { return Kind.BREAK; }

  1170         public Name getLabel() { return label; }

  1171         @Override

  1172         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1173             return v.visitBreak(this, d);

  1174         }

  1175         @Override

  1176         public int getTag() {

  1177             return BREAK;

  1178         }

  1179     }

  1181     /**

  1182      * A continue of a loop.

  1183      */

  1184     public static class JCContinue extends JCStatement implements ContinueTree {

  1185         public Name label;

  1186         public JCTree target;

  1187         protected JCContinue(Name label, JCTree target) {

  1188             this.label = label;

  1189             this.target = target;

  1190         }

  1191         @Override

  1192         public void accept(Visitor v) { v.visitContinue(this); }

  1194         public Kind getKind() { return Kind.CONTINUE; }

  1195         public Name getLabel() { return label; }

  1196         @Override

  1197         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1198             return v.visitContinue(this, d);

  1199         }

  1200         @Override

  1201         public int getTag() {

  1202             return CONTINUE;

  1203         }

  1204     }

  1206     /**

  1207      * A return statement.

  1208      */

  1209     public static class JCReturn extends JCStatement implements ReturnTree {

  1210         public JCExpression expr;

  1211         protected JCReturn(JCExpression expr) {

  1212             this.expr = expr;

  1213         }

  1214         @Override

  1215         public void accept(Visitor v) { v.visitReturn(this); }

  1217         public Kind getKind() { return Kind.RETURN; }

  1218         public JCExpression getExpression() { return expr; }

  1219         @Override

  1220         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1221             return v.visitReturn(this, d);

  1222         }

  1223         @Override

  1224         public int getTag() {

  1225             return RETURN;

  1226         }

  1227     }

  1229     /**

  1230      * A throw statement.

  1231      */

  1232     public static class JCThrow extends JCStatement implements ThrowTree {

  1233         public JCExpression expr;

  1234         protected JCThrow(JCTree expr) {

  1235             this.expr = (JCExpression)expr;

  1236         }

  1237         @Override

  1238         public void accept(Visitor v) { v.visitThrow(this); }

  1240         public Kind getKind() { return Kind.THROW; }

  1241         public JCExpression getExpression() { return expr; }

  1242         @Override

  1243         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1244             return v.visitThrow(this, d);

  1245         }

  1246         @Override

  1247         public int getTag() {

  1248             return THROW;

  1249         }

  1250     }

  1252     /**

  1253      * An assert statement.

  1254      */

  1255     public static class JCAssert extends JCStatement implements AssertTree {

  1256         public JCExpression cond;

  1257         public JCExpression detail;

  1258         protected JCAssert(JCExpression cond, JCExpression detail) {

  1259             this.cond = cond;

  1260             this.detail = detail;

  1261         }

  1262         @Override

  1263         public void accept(Visitor v) { v.visitAssert(this); }

  1265         public Kind getKind() { return Kind.ASSERT; }

  1266         public JCExpression getCondition() { return cond; }

  1267         public JCExpression getDetail() { return detail; }

  1268         @Override

  1269         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1270             return v.visitAssert(this, d);

  1271         }

  1272         @Override

  1273         public int getTag() {

  1274             return ASSERT;

  1275         }

  1276     }

  1278     /**

  1279      * A method invocation

  1280      */

  1281     public static class JCMethodInvocation extends JCExpression implements MethodInvocationTree {

  1282         public List<JCExpression> typeargs;

  1283         public JCExpression meth;

  1284         public List<JCExpression> args;

  1285         public Type varargsElement;

  1286         protected JCMethodInvocation(List<JCExpression> typeargs,

  1287                         JCExpression meth,

  1288                         List<JCExpression> args)

  1289         {

  1290             this.typeargs = (typeargs == null) ? List.<JCExpression>nil()

  1291                                                : typeargs;

  1292             this.meth = meth;

  1293             this.args = args;

  1294         }

  1295         @Override

  1296         public void accept(Visitor v) { v.visitApply(this); }

  1298         public Kind getKind() { return Kind.METHOD_INVOCATION; }

  1299         public List<JCExpression> getTypeArguments() {

  1300             return typeargs;

  1301         }

  1302         public JCExpression getMethodSelect() { return meth; }

  1303         public List<JCExpression> getArguments() {

  1304             return args;

  1305         }

  1306         @Override

  1307         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1308             return v.visitMethodInvocation(this, d);

  1309         }

  1310         @Override

  1311         public JCMethodInvocation setType(Type type) {

  1312             super.setType(type);

  1313             return this;

  1314         }

  1315         @Override

  1316         public int getTag() {

  1317             return(APPLY);

  1318         }

  1319     }

  1321     /**

  1322      * A new(...) operation.

  1323      */

  1324     public static class JCNewClass extends JCExpression implements NewClassTree {

  1325         public JCExpression encl;

  1326         public List<JCExpression> typeargs;

  1327         public JCExpression clazz;

  1328         public List<JCExpression> args;

  1329         public JCClassDecl def;

  1330         public Symbol constructor;

  1331         public Type varargsElement;

  1332         protected JCNewClass(JCExpression encl,

  1333                            List<JCExpression> typeargs,

  1334                            JCExpression clazz,

  1335                            List<JCExpression> args,

  1336                            JCClassDecl def)

  1337         {

  1338             this.encl = encl;

  1339             this.typeargs = (typeargs == null) ? List.<JCExpression>nil()

  1340                                                : typeargs;

  1341             this.clazz = clazz;

  1342             this.args = args;

  1343             this.def = def;

  1344         }

  1345         @Override

  1346         public void accept(Visitor v) { v.visitNewClass(this); }

  1348         public Kind getKind() { return Kind.NEW_CLASS; }

  1349         public JCExpression getEnclosingExpression() { // expr.new C< ... > ( ... )

  1350             return encl;

  1351         }

  1352         public List<JCExpression> getTypeArguments() {

  1353             return typeargs;

  1354         }

  1355         public JCExpression getIdentifier() { return clazz; }

  1356         public List<JCExpression> getArguments() {

  1357             return args;

  1358         }

  1359         public JCClassDecl getClassBody() { return def; }

  1360         @Override

  1361         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1362             return v.visitNewClass(this, d);

  1363         }

  1364         @Override

  1365         public int getTag() {

  1366             return NEWCLASS;

  1367         }

  1368     }

  1370     /**

  1371      * A new[...] operation.

  1372      */

  1373     public static class JCNewArray extends JCExpression implements NewArrayTree {

  1374         public JCExpression elemtype;

  1375         public List<JCExpression> dims;

  1376         public List<JCExpression> elems;

  1377         protected JCNewArray(JCExpression elemtype,

  1378                            List<JCExpression> dims,

  1379                            List<JCExpression> elems)

  1380         {

  1381             this.elemtype = elemtype;

  1382             this.dims = dims;

  1383             this.elems = elems;

  1384         }

  1385         @Override

  1386         public void accept(Visitor v) { v.visitNewArray(this); }

  1388         public Kind getKind() { return Kind.NEW_ARRAY; }

  1389         public JCExpression getType() { return elemtype; }

  1390         public List<JCExpression> getDimensions() {

  1391             return dims;

  1392         }

  1393         public List<JCExpression> getInitializers() {

  1394             return elems;

  1395         }

  1396         @Override

  1397         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1398             return v.visitNewArray(this, d);

  1399         }

  1400         @Override

  1401         public int getTag() {

  1402             return NEWARRAY;

  1403         }

  1404     }

  1406     /**

  1407      * A parenthesized subexpression ( ... )

  1408      */

  1409     public static class JCParens extends JCExpression implements ParenthesizedTree {

  1410         public JCExpression expr;

  1411         protected JCParens(JCExpression expr) {

  1412             this.expr = expr;

  1413         }

  1414         @Override

  1415         public void accept(Visitor v) { v.visitParens(this); }

  1417         public Kind getKind() { return Kind.PARENTHESIZED; }

  1418         public JCExpression getExpression() { return expr; }

  1419         @Override

  1420         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1421             return v.visitParenthesized(this, d);

  1422         }

  1423         @Override

  1424         public int getTag() {

  1425             return PARENS;

  1426         }

  1427     }

  1429     /**

  1430      * A assignment with "=".

  1431      */

  1432     public static class JCAssign extends JCExpression implements AssignmentTree {

  1433         public JCExpression lhs;

  1434         public JCExpression rhs;

  1435         protected JCAssign(JCExpression lhs, JCExpression rhs) {

  1436             this.lhs = lhs;

  1437             this.rhs = rhs;

  1438         }

  1439         @Override

  1440         public void accept(Visitor v) { v.visitAssign(this); }

  1442         public Kind getKind() { return Kind.ASSIGNMENT; }

  1443         public JCExpression getVariable() { return lhs; }

  1444         public JCExpression getExpression() { return rhs; }

  1445         @Override

  1446         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1447             return v.visitAssignment(this, d);

  1448         }

  1449         @Override

  1450         public int getTag() {

  1451             return ASSIGN;

  1452         }

  1453     }

  1455     /**

  1456      * An assignment with "+=", "|=" ...

  1457      */

  1458     public static class JCAssignOp extends JCExpression implements CompoundAssignmentTree {

  1459         private int opcode;

  1460         public JCExpression lhs;

  1461         public JCExpression rhs;

  1462         public Symbol operator;

  1463         protected JCAssignOp(int opcode, JCTree lhs, JCTree rhs, Symbol operator) {

  1464             this.opcode = opcode;

  1465             this.lhs = (JCExpression)lhs;

  1466             this.rhs = (JCExpression)rhs;

  1467             this.operator = operator;

  1468         }

  1469         @Override

  1470         public void accept(Visitor v) { v.visitAssignop(this); }

  1472         public Kind getKind() { return TreeInfo.tagToKind(getTag()); }

  1473         public JCExpression getVariable() { return lhs; }

  1474         public JCExpression getExpression() { return rhs; }

  1475         public Symbol getOperator() {

  1476             return operator;

  1477         }

  1478         @Override

  1479         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1480             return v.visitCompoundAssignment(this, d);

  1481         }

  1482         @Override

  1483         public int getTag() {

  1484             return opcode;

  1485         }

  1486     }

  1488     /**

  1489      * A unary operation.

  1490      */

  1491     public static class JCUnary extends JCExpression implements UnaryTree {

  1492         private int opcode;

  1493         public JCExpression arg;

  1494         public Symbol operator;

  1495         protected JCUnary(int opcode, JCExpression arg) {

  1496             this.opcode = opcode;

  1497             this.arg = arg;

  1498         }

  1499         @Override

  1500         public void accept(Visitor v) { v.visitUnary(this); }

  1502         public Kind getKind() { return TreeInfo.tagToKind(getTag()); }

  1503         public JCExpression getExpression() { return arg; }

  1504         public Symbol getOperator() {

  1505             return operator;

  1506         }

  1507         @Override

  1508         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1509             return v.visitUnary(this, d);

  1510         }

  1511         @Override

  1512         public int getTag() {

  1513             return opcode;

  1514         }

  1516         public void setTag(int tag) {

  1517             opcode = tag;

  1518         }

  1519     }

  1521     /**

  1522      * A binary operation.

  1523      */

  1524     public static class JCBinary extends JCExpression implements BinaryTree {

  1525         private int opcode;

  1526         public JCExpression lhs;

  1527         public JCExpression rhs;

  1528         public Symbol operator;

  1529         protected JCBinary(int opcode,

  1530                          JCExpression lhs,

  1531                          JCExpression rhs,

  1532                          Symbol operator) {

  1533             this.opcode = opcode;

  1534             this.lhs = lhs;

  1535             this.rhs = rhs;

  1536             this.operator = operator;

  1537         }

  1538         @Override

  1539         public void accept(Visitor v) { v.visitBinary(this); }

  1541         public Kind getKind() { return TreeInfo.tagToKind(getTag()); }

  1542         public JCExpression getLeftOperand() { return lhs; }

  1543         public JCExpression getRightOperand() { return rhs; }

  1544         public Symbol getOperator() {

  1545             return operator;

  1546         }

  1547         @Override

  1548         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1549             return v.visitBinary(this, d);

  1550         }

  1551         @Override

  1552         public int getTag() {

  1553             return opcode;

  1554         }

  1555     }

  1557     /**

  1558      * A type cast.

  1559      */

  1560     public static class JCTypeCast extends JCExpression implements TypeCastTree {

  1561         public JCTree clazz;

  1562         public JCExpression expr;

  1563         protected JCTypeCast(JCTree clazz, JCExpression expr) {

  1564             this.clazz = clazz;

  1565             this.expr = expr;

  1566         }

  1567         @Override

  1568         public void accept(Visitor v) { v.visitTypeCast(this); }

  1570         public Kind getKind() { return Kind.TYPE_CAST; }

  1571         public JCTree getType() { return clazz; }

  1572         public JCExpression getExpression() { return expr; }

  1573         @Override

  1574         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1575             return v.visitTypeCast(this, d);

  1576         }

  1577         @Override

  1578         public int getTag() {

  1579             return TYPECAST;

  1580         }

  1581     }

  1583     /**

  1584      * A type test.

  1585      */

  1586     public static class JCInstanceOf extends JCExpression implements InstanceOfTree {

  1587         public JCExpression expr;

  1588         public JCTree clazz;

  1589         protected JCInstanceOf(JCExpression expr, JCTree clazz) {

  1590             this.expr = expr;

  1591             this.clazz = clazz;

  1592         }

  1593         @Override

  1594         public void accept(Visitor v) { v.visitTypeTest(this); }

  1596         public Kind getKind() { return Kind.INSTANCE_OF; }

  1597         public JCTree getType() { return clazz; }

  1598         public JCExpression getExpression() { return expr; }

  1599         @Override

  1600         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1601             return v.visitInstanceOf(this, d);

  1602         }

  1603         @Override

  1604         public int getTag() {

  1605             return TYPETEST;

  1606         }

  1607     }

  1609     /**

  1610      * An array selection

  1611      */

  1612     public static class JCArrayAccess extends JCExpression implements ArrayAccessTree {

  1613         public JCExpression indexed;

  1614         public JCExpression index;

  1615         protected JCArrayAccess(JCExpression indexed, JCExpression index) {

  1616             this.indexed = indexed;

  1617             this.index = index;

  1618         }

  1619         @Override

  1620         public void accept(Visitor v) { v.visitIndexed(this); }

  1622         public Kind getKind() { return Kind.ARRAY_ACCESS; }

  1623         public JCExpression getExpression() { return indexed; }

  1624         public JCExpression getIndex() { return index; }

  1625         @Override

  1626         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1627             return v.visitArrayAccess(this, d);

  1628         }

  1629         @Override

  1630         public int getTag() {

  1631             return INDEXED;

  1632         }

  1633     }

  1635     /**

  1636      * Selects through packages and classes

  1637      * @param selected selected Tree hierarchie

  1638      * @param selector name of field to select thru

  1639      * @param sym symbol of the selected class

  1640      */

  1641     public static class JCFieldAccess extends JCExpression implements MemberSelectTree {

  1642         public JCExpression selected;

  1643         public Name name;

  1644         public Symbol sym;

  1645         protected JCFieldAccess(JCExpression selected, Name name, Symbol sym) {

  1646             this.selected = selected;

  1647             this.name = name;

  1648             this.sym = sym;

  1649         }

  1650         @Override

  1651         public void accept(Visitor v) { v.visitSelect(this); }

  1653         public Kind getKind() { return Kind.MEMBER_SELECT; }

  1654         public JCExpression getExpression() { return selected; }

  1655         @Override

  1656         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1657             return v.visitMemberSelect(this, d);

  1658         }

  1659         public Name getIdentifier() { return name; }

  1660         @Override

  1661         public int getTag() {

  1662             return SELECT;

  1663         }

  1664     }

  1666     /**

  1667      * An identifier

  1668      * @param idname the name

  1669      * @param sym the symbol

  1670      */

  1671     public static class JCIdent extends JCExpression implements IdentifierTree {

  1672         public Name name;

  1673         public Symbol sym;

  1674         protected JCIdent(Name name, Symbol sym) {

  1675             this.name = name;

  1676             this.sym = sym;

  1677         }

  1678         @Override

  1679         public void accept(Visitor v) { v.visitIdent(this); }

  1681         public Kind getKind() { return Kind.IDENTIFIER; }

  1682         public Name getName() { return name; }

  1683         @Override

  1684         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1685             return v.visitIdentifier(this, d);

  1686         }

  1687         public int getTag() {

  1688             return IDENT;

  1689         }

  1690     }

  1692     /**

  1693      * A constant value given literally.

  1694      * @param value value representation

  1695      */

  1696     public static class JCLiteral extends JCExpression implements LiteralTree {

  1697         public int typetag;

  1698         public Object value;

  1699         protected JCLiteral(int typetag, Object value) {

  1700             this.typetag = typetag;

  1701             this.value = value;

  1702         }

  1703         @Override

  1704         public void accept(Visitor v) { v.visitLiteral(this); }

  1706         public Kind getKind() {

  1707             switch (typetag) {

  1708             case TypeTags.INT:

  1709                 return Kind.INT_LITERAL;

  1710             case TypeTags.LONG:

  1711                 return Kind.LONG_LITERAL;

  1712             case TypeTags.FLOAT:

  1713                 return Kind.FLOAT_LITERAL;

  1714             case TypeTags.DOUBLE:

  1715                 return Kind.DOUBLE_LITERAL;

  1716             case TypeTags.BOOLEAN:

  1717                 return Kind.BOOLEAN_LITERAL;

  1718             case TypeTags.CHAR:

  1719                 return Kind.CHAR_LITERAL;

  1720             case TypeTags.CLASS:

  1721                 return Kind.STRING_LITERAL;

  1722             case TypeTags.BOT:

  1723                 return Kind.NULL_LITERAL;

  1724             default:

  1725                 throw new AssertionError("unknown literal kind " + this);

  1726             }

  1727         }

  1728         public Object getValue() {

  1729             switch (typetag) {

  1730                 case TypeTags.BOOLEAN:

  1731                     int bi = (Integer) value;

  1732                     return (bi != 0);

  1733                 case TypeTags.CHAR:

  1734                     int ci = (Integer) value;

  1735                     char c = (char) ci;

  1736                     if (c != ci)

  1737                         throw new AssertionError("bad value for char literal");

  1738                     return c;

  1739                 default:

  1740                     return value;

  1741             }

  1742         }

  1743         @Override

  1744         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1745             return v.visitLiteral(this, d);

  1746         }

  1747         @Override

  1748         public JCLiteral setType(Type type) {

  1749             super.setType(type);

  1750             return this;

  1751         }

  1752         @Override

  1753         public int getTag() {

  1754             return LITERAL;

  1755         }

  1756     }

  1758     /**

  1759      * Identifies a basic type.

  1760      * @param tag the basic type id

  1761      * @see TypeTags

  1762      */

  1763     public static class JCPrimitiveTypeTree extends JCExpression implements PrimitiveTypeTree {

  1764         public int typetag;

  1765         protected JCPrimitiveTypeTree(int typetag) {

  1766             this.typetag = typetag;

  1767         }

  1768         @Override

  1769         public void accept(Visitor v) { v.visitTypeIdent(this); }

  1771         public Kind getKind() { return Kind.PRIMITIVE_TYPE; }

  1772         public TypeKind getPrimitiveTypeKind() {

  1773             switch (typetag) {

  1774             case TypeTags.BOOLEAN:

  1775                 return TypeKind.BOOLEAN;

  1776             case TypeTags.BYTE:

  1777                 return TypeKind.BYTE;

  1778             case TypeTags.SHORT:

  1779                 return TypeKind.SHORT;

  1780             case TypeTags.INT:

  1781                 return TypeKind.INT;

  1782             case TypeTags.LONG:

  1783                 return TypeKind.LONG;

  1784             case TypeTags.CHAR:

  1785                 return TypeKind.CHAR;

  1786             case TypeTags.FLOAT:

  1787                 return TypeKind.FLOAT;

  1788             case TypeTags.DOUBLE:

  1789                 return TypeKind.DOUBLE;

  1790             case TypeTags.VOID:

  1791                 return TypeKind.VOID;

  1792             default:

  1793                 throw new AssertionError("unknown primitive type " + this);

  1794             }

  1795         }

  1796         @Override

  1797         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1798             return v.visitPrimitiveType(this, d);

  1799         }

  1800         @Override

  1801         public int getTag() {

  1802             return TYPEIDENT;

  1803         }

  1804     }

  1806     /**

  1807      * An array type, A[]

  1808      */

  1809     public static class JCArrayTypeTree extends JCExpression implements ArrayTypeTree {

  1810         public JCExpression elemtype;

  1811         protected JCArrayTypeTree(JCExpression elemtype) {

  1812             this.elemtype = elemtype;

  1813         }

  1814         @Override

  1815         public void accept(Visitor v) { v.visitTypeArray(this); }

  1817         public Kind getKind() { return Kind.ARRAY_TYPE; }

  1818         public JCTree getType() { return elemtype; }

  1819         @Override

  1820         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1821             return v.visitArrayType(this, d);

  1822         }

  1823         @Override

  1824         public int getTag() {

  1825             return TYPEARRAY;

  1826         }

  1827     }

  1829     /**

  1830      * A parameterized type, T<...>

  1831      */

  1832     public static class JCTypeApply extends JCExpression implements ParameterizedTypeTree {

  1833         public JCExpression clazz;

  1834         public List<JCExpression> arguments;

  1835         protected JCTypeApply(JCExpression clazz, List<JCExpression> arguments) {

  1836             this.clazz = clazz;

  1837             this.arguments = arguments;

  1838         }

  1839         @Override

  1840         public void accept(Visitor v) { v.visitTypeApply(this); }

  1842         public Kind getKind() { return Kind.PARAMETERIZED_TYPE; }

  1843         public JCTree getType() { return clazz; }

  1844         public List<JCExpression> getTypeArguments() {

  1845             return arguments;

  1846         }

  1847         @Override

  1848         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1849             return v.visitParameterizedType(this, d);

  1850         }

  1851         @Override

  1852         public int getTag() {

  1853             return TYPEAPPLY;

  1854         }

  1855     }

  1857     /**

  1858      * A formal class parameter.

  1859      * @param name name

  1860      * @param bounds bounds

  1861      */

  1862     public static class JCTypeParameter extends JCTree implements TypeParameterTree {

  1863         public Name name;

  1864         public List<JCExpression> bounds;

  1865         protected JCTypeParameter(Name name, List<JCExpression> bounds) {

  1866             this.name = name;

  1867             this.bounds = bounds;

  1868         }

  1869         @Override

  1870         public void accept(Visitor v) { v.visitTypeParameter(this); }

  1872         public Kind getKind() { return Kind.TYPE_PARAMETER; }

  1873         public Name getName() { return name; }

  1874         public List<JCExpression> getBounds() {

  1875             return bounds;

  1876         }

  1877         @Override

  1878         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1879             return v.visitTypeParameter(this, d);

  1880         }

  1881         @Override

  1882         public int getTag() {

  1883             return TYPEPARAMETER;

  1884         }

  1885     }

  1887     public static class JCWildcard extends JCExpression implements WildcardTree {

  1888         public TypeBoundKind kind;

  1889         public JCTree inner;

  1890         protected JCWildcard(TypeBoundKind kind, JCTree inner) {

  1891             kind.getClass(); // null-check

  1892             this.kind = kind;

  1893             this.inner = inner;

  1894         }

  1895         @Override

  1896         public void accept(Visitor v) { v.visitWildcard(this); }

  1898         public Kind getKind() {

  1899             switch (kind.kind) {

  1900             case UNBOUND:

  1901                 return Kind.UNBOUNDED_WILDCARD;

  1902             case EXTENDS:

  1903                 return Kind.EXTENDS_WILDCARD;

  1904             case SUPER:

  1905                 return Kind.SUPER_WILDCARD;

  1906             default:

  1907                 throw new AssertionError("Unknown wildcard bound " + kind);

  1908             }

  1909         }

  1910         public JCTree getBound() { return inner; }

  1911         @Override

  1912         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1913             return v.visitWildcard(this, d);

  1914         }

  1915         @Override

  1916         public int getTag() {

  1917             return WILDCARD;

  1918         }

  1919     }

  1921     public static class TypeBoundKind extends JCTree {

  1922         public BoundKind kind;

  1923         protected TypeBoundKind(BoundKind kind) {

  1924             this.kind = kind;

  1925         }

  1926         @Override

  1927         public void accept(Visitor v) { v.visitTypeBoundKind(this); }

  1929         public Kind getKind() {

  1930             throw new AssertionError("TypeBoundKind is not part of a public API");

  1931         }

  1932         @Override

  1933         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1934             throw new AssertionError("TypeBoundKind is not part of a public API");

  1935         }

  1936         @Override

  1937         public int getTag() {

  1938             return TYPEBOUNDKIND;

  1939         }

  1940     }

  1942     public static class JCAnnotation extends JCExpression implements AnnotationTree {

  1943         public JCTree annotationType;

  1944         public List<JCExpression> args;

  1945         protected JCAnnotation(JCTree annotationType, List<JCExpression> args) {

  1946             this.annotationType = annotationType;

  1947             this.args = args;

  1948         }

  1949         @Override

  1950         public void accept(Visitor v) { v.visitAnnotation(this); }

  1952         public Kind getKind() { return Kind.ANNOTATION; }

  1953         public JCTree getAnnotationType() { return annotationType; }

  1954         public List<JCExpression> getArguments() {

  1955             return args;

  1956         }

  1957         @Override

  1958         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1959             return v.visitAnnotation(this, d);

  1960         }

  1961         @Override

  1962         public int getTag() {

  1963             return ANNOTATION;

  1964         }

  1965     }

  1967     public static class JCModifiers extends JCTree implements com.sun.source.tree.ModifiersTree {

  1968         public long flags;

  1969         public List<JCAnnotation> annotations;

  1970         protected JCModifiers(long flags, List<JCAnnotation> annotations) {

  1971             this.flags = flags;

  1972             this.annotations = annotations;

  1973         }

  1974         @Override

  1975         public void accept(Visitor v) { v.visitModifiers(this); }

  1977         public Kind getKind() { return Kind.MODIFIERS; }

  1978         public Set<Modifier> getFlags() {

  1979             return Flags.asModifierSet(flags);

  1980         }

  1981         public List<JCAnnotation> getAnnotations() {

  1982             return annotations;

  1983         }

  1984         @Override

  1985         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  1986             return v.visitModifiers(this, d);

  1987         }

  1988         @Override

  1989         public int getTag() {

  1990             return MODIFIERS;

  1991         }

  1992     }

  1994     public static class JCErroneous extends JCExpression

  1995             implements com.sun.source.tree.ErroneousTree {

  1996         public List<? extends JCTree> errs;

  1997         protected JCErroneous(List<? extends JCTree> errs) {

  1998             this.errs = errs;

  1999         }

  2000         @Override

  2001         public void accept(Visitor v) { v.visitErroneous(this); }

  2003         public Kind getKind() { return Kind.ERRONEOUS; }

  2005         public List<? extends JCTree> getErrorTrees() {

  2006             return errs;

  2007         }

  2009         @Override

  2010         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  2011             return v.visitErroneous(this, d);

  2012         }

  2013         @Override

  2014         public int getTag() {

  2015             return ERRONEOUS;

  2016         }

  2017     }

  2019     /** (let int x = 3; in x+2) */

  2020     public static class LetExpr extends JCExpression {

  2021         public List<JCVariableDecl> defs;

  2022         public JCTree expr;

  2023         protected LetExpr(List<JCVariableDecl> defs, JCTree expr) {

  2024             this.defs = defs;

  2025             this.expr = expr;

  2026         }

  2027         @Override

  2028         public void accept(Visitor v) { v.visitLetExpr(this); }

  2030         public Kind getKind() {

  2031             throw new AssertionError("LetExpr is not part of a public API");

  2032         }

  2033         @Override

  2034         public <R,D> R accept(TreeVisitor<R,D> v, D d) {

  2035             throw new AssertionError("LetExpr is not part of a public API");

  2036         }

  2037         @Override

  2038         public int getTag() {

  2039             return LETEXPR;

  2040         }

  2041     }

  2043     /** An interface for tree factories

  2044      */

  2045     public interface Factory {

  2046         JCCompilationUnit TopLevel(List<JCAnnotation> packageAnnotations,

  2047                                    JCExpression pid,

  2048                                    List<JCTree> defs);

  2049         JCImport Import(JCTree qualid, boolean staticImport);

  2050         JCClassDecl ClassDef(JCModifiers mods,

  2051                           Name name,

  2052                           List<JCTypeParameter> typarams,

  2053                           JCTree extending,

  2054                           List<JCExpression> implementing,

  2055                           List<JCTree> defs);

  2056         JCMethodDecl MethodDef(JCModifiers mods,

  2057                             Name name,

  2058                             JCExpression restype,

  2059                             List<JCTypeParameter> typarams,

  2060                             List<JCVariableDecl> params,

  2061                             List<JCExpression> thrown,

  2062                             JCBlock body,

  2063                             JCExpression defaultValue);

  2064         JCVariableDecl VarDef(JCModifiers mods,

  2065                       Name name,

  2066                       JCExpression vartype,

  2067                       JCExpression init);

  2068         JCSkip Skip();

  2069         JCBlock Block(long flags, List<JCStatement> stats);

  2070         JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);

  2071         JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);

  2072         JCForLoop ForLoop(List<JCStatement> init,

  2073                         JCExpression cond,

  2074                         List<JCExpressionStatement> step,

  2075                         JCStatement body);

  2076         JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);

  2077         JCLabeledStatement Labelled(Name label, JCStatement body);

  2078         JCSwitch Switch(JCExpression selector, List<JCCase> cases);

  2079         JCCase Case(JCExpression pat, List<JCStatement> stats);

  2080         JCSynchronized Synchronized(JCExpression lock, JCBlock body);

  2081         JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);

  2082         JCCatch Catch(JCVariableDecl param, JCBlock body);

  2083         JCConditional Conditional(JCExpression cond,

  2084                                 JCExpression thenpart,

  2085                                 JCExpression elsepart);

  2086         JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);

  2087         JCExpressionStatement Exec(JCExpression expr);

  2088         JCBreak Break(Name label);

  2089         JCContinue Continue(Name label);

  2090         JCReturn Return(JCExpression expr);

  2091         JCThrow Throw(JCTree expr);

  2092         JCAssert Assert(JCExpression cond, JCExpression detail);

  2093         JCMethodInvocation Apply(List<JCExpression> typeargs,

  2094                     JCExpression fn,

  2095                     List<JCExpression> args);

  2096         JCNewClass NewClass(JCExpression encl,

  2097                           List<JCExpression> typeargs,

  2098                           JCExpression clazz,

  2099                           List<JCExpression> args,

  2100                           JCClassDecl def);

  2101         JCNewArray NewArray(JCExpression elemtype,

  2102                           List<JCExpression> dims,

  2103                           List<JCExpression> elems);

  2104         JCParens Parens(JCExpression expr);

  2105         JCAssign Assign(JCExpression lhs, JCExpression rhs);

  2106         JCAssignOp Assignop(int opcode, JCTree lhs, JCTree rhs);

  2107         JCUnary Unary(int opcode, JCExpression arg);

  2108         JCBinary Binary(int opcode, JCExpression lhs, JCExpression rhs);

  2109         JCTypeCast TypeCast(JCTree expr, JCExpression type);

  2110         JCInstanceOf TypeTest(JCExpression expr, JCTree clazz);

  2111         JCArrayAccess Indexed(JCExpression indexed, JCExpression index);

  2112         JCFieldAccess Select(JCExpression selected, Name selector);

  2113         JCIdent Ident(Name idname);

  2114         JCLiteral Literal(int tag, Object value);

  2115         JCPrimitiveTypeTree TypeIdent(int typetag);

  2116         JCArrayTypeTree TypeArray(JCExpression elemtype);

  2117         JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments);

  2118         JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds);

  2119         JCWildcard Wildcard(TypeBoundKind kind, JCTree type);

  2120         TypeBoundKind TypeBoundKind(BoundKind kind);

  2121         JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args);

  2122         JCModifiers Modifiers(long flags, List<JCAnnotation> annotations);

  2123         JCErroneous Erroneous(List<? extends JCTree> errs);

  2124         LetExpr LetExpr(List<JCVariableDecl> defs, JCTree expr);

  2125     }

  2127     /** A generic visitor class for trees.

  2128      */

  2129     public static abstract class Visitor {

  2130         public void visitTopLevel(JCCompilationUnit that)    { visitTree(that); }

  2131         public void visitImport(JCImport that)               { visitTree(that); }

  2132         public void visitClassDef(JCClassDecl that)          { visitTree(that); }

  2133         public void visitMethodDef(JCMethodDecl that)        { visitTree(that); }

  2134         public void visitVarDef(JCVariableDecl that)         { visitTree(that); }

  2135         public void visitSkip(JCSkip that)                   { visitTree(that); }

  2136         public void visitBlock(JCBlock that)                 { visitTree(that); }

  2137         public void visitDoLoop(JCDoWhileLoop that)          { visitTree(that); }

  2138         public void visitWhileLoop(JCWhileLoop that)         { visitTree(that); }

  2139         public void visitForLoop(JCForLoop that)             { visitTree(that); }

  2140         public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }

  2141         public void visitLabelled(JCLabeledStatement that)   { visitTree(that); }

  2142         public void visitSwitch(JCSwitch that)               { visitTree(that); }

  2143         public void visitCase(JCCase that)                   { visitTree(that); }

  2144         public void visitSynchronized(JCSynchronized that)   { visitTree(that); }

  2145         public void visitTry(JCTry that)                     { visitTree(that); }

  2146         public void visitCatch(JCCatch that)                 { visitTree(that); }

  2147         public void visitConditional(JCConditional that)     { visitTree(that); }

  2148         public void visitIf(JCIf that)                       { visitTree(that); }

  2149         public void visitExec(JCExpressionStatement that)    { visitTree(that); }

  2150         public void visitBreak(JCBreak that)                 { visitTree(that); }

  2151         public void visitContinue(JCContinue that)           { visitTree(that); }

  2152         public void visitReturn(JCReturn that)               { visitTree(that); }

  2153         public void visitThrow(JCThrow that)                 { visitTree(that); }

  2154         public void visitAssert(JCAssert that)               { visitTree(that); }

  2155         public void visitApply(JCMethodInvocation that)      { visitTree(that); }

  2156         public void visitNewClass(JCNewClass that)           { visitTree(that); }

  2157         public void visitNewArray(JCNewArray that)           { visitTree(that); }

  2158         public void visitParens(JCParens that)               { visitTree(that); }

  2159         public void visitAssign(JCAssign that)               { visitTree(that); }

  2160         public void visitAssignop(JCAssignOp that)           { visitTree(that); }

  2161         public void visitUnary(JCUnary that)                 { visitTree(that); }

  2162         public void visitBinary(JCBinary that)               { visitTree(that); }

  2163         public void visitTypeCast(JCTypeCast that)           { visitTree(that); }

  2164         public void visitTypeTest(JCInstanceOf that)         { visitTree(that); }

  2165         public void visitIndexed(JCArrayAccess that)         { visitTree(that); }

  2166         public void visitSelect(JCFieldAccess that)          { visitTree(that); }

  2167         public void visitIdent(JCIdent that)                 { visitTree(that); }

  2168         public void visitLiteral(JCLiteral that)             { visitTree(that); }

  2169         public void visitTypeIdent(JCPrimitiveTypeTree that) { visitTree(that); }

  2170         public void visitTypeArray(JCArrayTypeTree that)     { visitTree(that); }

  2171         public void visitTypeApply(JCTypeApply that)         { visitTree(that); }

  2172         public void visitTypeParameter(JCTypeParameter that) { visitTree(that); }

  2173         public void visitWildcard(JCWildcard that)           { visitTree(that); }

  2174         public void visitTypeBoundKind(TypeBoundKind that)   { visitTree(that); }

  2175         public void visitAnnotation(JCAnnotation that)       { visitTree(that); }

  2176         public void visitModifiers(JCModifiers that)         { visitTree(that); }

  2177         public void visitErroneous(JCErroneous that)         { visitTree(that); }

  2178         public void visitLetExpr(LetExpr that)               { visitTree(that); }

  2180         public void visitTree(JCTree that)                   { assert false; }

  2181     }

  2183 }

Mercurial > jdk8-mips64-public > langtools / file revision

src/share/classes/com/sun/tools/javac/tree/JCTree.java@5c9cdeb740f2

src/share/classes/com/sun/tools/javac/tree/JCTree.java