38 import com.sun.source.tree.MemberReferenceTree.ReferenceMode;

    38 import com.sun.source.tree.MemberReferenceTree.ReferenceMode;

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

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

    40 import com.sun.tools.javac.code.Scope.*;

    40 import com.sun.tools.javac.code.Scope.*;

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

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

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

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

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

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

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

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

    45 import static com.sun.tools.javac.tree.JCTree.Tag.*;

    46 import static com.sun.tools.javac.tree.JCTree.Tag.*;

    46 

    47 

    47 /**

    48 /**

   437 

   438 

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

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

   439      */

   440      */

   440     public abstract void accept(Visitor v);

   441     public abstract void accept(Visitor v);

   441 

   442 

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

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

   443 

   445 

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

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

   445      */

   447      */

   446     @Override

   448     @Override

   506             this.defs = defs;

   508             this.defs = defs;

   507         }

   509         }

   508         @Override

   510         @Override

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

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

   510 

   512 

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

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

   512 

   515 

   513         public JCPackageDecl getPackage() {

   517         public JCPackageDecl getPackage() {

   514             // PackageDecl must be the first entry if it exists

   518             // PackageDecl must be the first entry if it exists

   515             if (!defs.isEmpty() && defs.head.hasTag(PACKAGEDEF))

   519             if (!defs.isEmpty() && defs.head.hasTag(PACKAGEDEF))

   516                 return (JCPackageDecl)defs.head;

   520                 return (JCPackageDecl)defs.head;

   517             return null;

   521             return null;

   518         }

   522         }

   519         public List<JCAnnotation> getPackageAnnotations() {

   524         public List<JCAnnotation> getPackageAnnotations() {

   520             JCPackageDecl pd = getPackage();

   525             JCPackageDecl pd = getPackage();

   521             return pd != null ? pd.getAnnotations() : List.<JCAnnotation>nil();

   526             return pd != null ? pd.getAnnotations() : List.<JCAnnotation>nil();

   522         }

   527         }

   523         public ExpressionTree getPackageName() {

   529         public ExpressionTree getPackageName() {

   524             JCPackageDecl pd = getPackage();

   530             JCPackageDecl pd = getPackage();

   525             return pd != null ? pd.getPackageName() : null;

   531             return pd != null ? pd.getPackageName() : null;

   526         }

   532         }

   527 

   533 

   528         public List<JCImport> getImports() {

   535         public List<JCImport> getImports() {

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

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

   530             for (JCTree tree : defs) {

   537             for (JCTree tree : defs) {

   531                 if (tree.hasTag(IMPORT))

   538                 if (tree.hasTag(IMPORT))

   532                     imports.append((JCImport)tree);

   539                     imports.append((JCImport)tree);

   533                 else if (!tree.hasTag(PACKAGEDEF) && !tree.hasTag(SKIP))

   540                 else if (!tree.hasTag(PACKAGEDEF) && !tree.hasTag(SKIP))

   534                     break;

   541                     break;

   535             }

   542             }

   536             return imports.toList();

   543             return imports.toList();

   537         }

   544         }

   538         public JavaFileObject getSourceFile() {

   546         public JavaFileObject getSourceFile() {

   539             return sourcefile;

   547             return sourcefile;

   540         }

   548         }

   541         public Position.LineMap getLineMap() {

   550         public Position.LineMap getLineMap() {

   542             return lineMap;

   551             return lineMap;

   543         }

   552         }

   544         public List<JCTree> getTypeDecls() {

   554         public List<JCTree> getTypeDecls() {

   545             List<JCTree> typeDefs;

   555             List<JCTree> typeDefs;

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

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

   547                 if (!typeDefs.head.hasTag(PACKAGEDEF) && !typeDefs.head.hasTag(IMPORT))

   557                 if (!typeDefs.head.hasTag(PACKAGEDEF) && !typeDefs.head.hasTag(IMPORT))

   548                     break;

   558                     break;

   549             return typeDefs;

   559             return typeDefs;

   550         }

   560         }

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

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

   553             return v.visitCompilationUnit(this, d);

   563             return v.visitCompilationUnit(this, d);

   554         }

   564         }

   555 

   565 

   556         @Override

   566         @Override

   571             this.annotations = annotations;

   581             this.annotations = annotations;

   572             this.pid = pid;

   582             this.pid = pid;

   573         }

   583         }

   574         @Override

   584         @Override

   575         public void accept(Visitor v) { v.visitPackageDef(this); }

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

   576         public Kind getKind() {

   587         public Kind getKind() {

   577             return Kind.PACKAGE;

   588             return Kind.PACKAGE;

   578         }

   589         }

   579         public List<JCAnnotation> getAnnotations() {

   591         public List<JCAnnotation> getAnnotations() {

   580             return annotations;

   592             return annotations;

   581         }

   593         }

   582         public JCExpression getPackageName() {

   595         public JCExpression getPackageName() {

   583             return pid;

   596             return pid;

   584         }

   597         }

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

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

   587             return v.visitPackage(this, d);

   600             return v.visitPackage(this, d);

   588         }

   601         }

   589         @Override

   602         @Override

   590         public Tag getTag() {

   603         public Tag getTag() {

   604             this.staticImport = importStatic;

   617             this.staticImport = importStatic;

   605         }

   618         }

   606         @Override

   619         @Override

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

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

   608 

   621 

   609         public boolean isStatic() { return staticImport; }

   623         public boolean isStatic() { return staticImport; }

   610         public JCTree getQualifiedIdentifier() { return qualid; }

   625         public JCTree getQualifiedIdentifier() { return qualid; }

   611 

   626 

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

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

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

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

   615             return v.visitImport(this, d);

   631             return v.visitImport(this, d);

   616         }

   632         }

   617 

   633 

   618         @Override

   634         @Override

   726             this.sym = sym;

   742             this.sym = sym;

   727         }

   743         }

   728         @Override

   744         @Override

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

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

   730 

   746 

   731         public Kind getKind() {

   748         public Kind getKind() {

   732             if ((mods.flags & Flags.ANNOTATION) != 0)

   749             if ((mods.flags & Flags.ANNOTATION) != 0)

   733                 return Kind.ANNOTATION_TYPE;

   750                 return Kind.ANNOTATION_TYPE;

   734             else if ((mods.flags & Flags.INTERFACE) != 0)

   751             else if ((mods.flags & Flags.INTERFACE) != 0)

   735                 return Kind.INTERFACE;

   752                 return Kind.INTERFACE;

   737                 return Kind.ENUM;

   754                 return Kind.ENUM;

   738             else

   755             else

   739                 return Kind.CLASS;

   756                 return Kind.CLASS;

   740         }

   757         }

   741 

   758 

   742         public JCModifiers getModifiers() { return mods; }

   760         public JCModifiers getModifiers() { return mods; }

   743         public Name getSimpleName() { return name; }

   762         public Name getSimpleName() { return name; }

   744         public List<JCTypeParameter> getTypeParameters() {

   764         public List<JCTypeParameter> getTypeParameters() {

   745             return typarams;

   765             return typarams;

   746         }

   766         }

   747         public JCExpression getExtendsClause() { return extending; }

   768         public JCExpression getExtendsClause() { return extending; }

   748         public List<JCExpression> getImplementsClause() {

   770         public List<JCExpression> getImplementsClause() {

   749             return implementing;

   771             return implementing;

   750         }

   772         }

   751         public List<JCTree> getMembers() {

   774         public List<JCTree> getMembers() {

   752             return defs;

   775             return defs;

   753         }

   776         }

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

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

   756             return v.visitClass(this, d);

   779             return v.visitClass(this, d);

   757         }

   780         }

   758 

   781 

   759         @Override

   782         @Override

   811             this.sym = sym;

   834             this.sym = sym;

   812         }

   835         }

   813         @Override

   836         @Override

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

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

   815 

   838 

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

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

   817         public JCModifiers getModifiers() { return mods; }

   842         public JCModifiers getModifiers() { return mods; }

   818         public Name getName() { return name; }

   844         public Name getName() { return name; }

   819         public JCTree getReturnType() { return restype; }

   846         public JCTree getReturnType() { return restype; }

   820         public List<JCTypeParameter> getTypeParameters() {

   848         public List<JCTypeParameter> getTypeParameters() {

   821             return typarams;

   849             return typarams;

   822         }

   850         }

   823         public List<JCVariableDecl> getParameters() {

   852         public List<JCVariableDecl> getParameters() {

   824             return params;

   853             return params;

   825         }

   854         }

   826         public JCVariableDecl getReceiverParameter() { return recvparam; }

   856         public JCVariableDecl getReceiverParameter() { return recvparam; }

   827         public List<JCExpression> getThrows() {

   858         public List<JCExpression> getThrows() {

   828             return thrown;

   859             return thrown;

   829         }

   860         }

   830         public JCBlock getBody() { return body; }

   862         public JCBlock getBody() { return body; }

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

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

   832             return defaultValue;

   865             return defaultValue;

   833         }

   866         }

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

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

   836             return v.visitMethod(this, d);

   869             return v.visitMethod(this, d);

   837         }

   870         }

   838 

   871 

   839         @Override

   872         @Override

   885         }

   918         }

   886 

   919 

   887         @Override

   920         @Override

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

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

   889 

   922 

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

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

   891         public JCModifiers getModifiers() { return mods; }

   926         public JCModifiers getModifiers() { return mods; }

   892         public Name getName() { return name; }

   928         public Name getName() { return name; }

   893         public JCExpression getNameExpression() { return nameexpr; }

   930         public JCExpression getNameExpression() { return nameexpr; }

   894         public JCTree getType() { return vartype; }

   932         public JCTree getType() { return vartype; }

   895         public JCExpression getInitializer() {

   934         public JCExpression getInitializer() {

   896             return init;

   935             return init;

   897         }

   936         }

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

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

   900             return v.visitVariable(this, d);

   939             return v.visitVariable(this, d);

   901         }

   940         }

   902 

   941 

   903         @Override

   942         @Override

   913         protected JCSkip() {

   952         protected JCSkip() {

   914         }

   953         }

   915         @Override

   954         @Override

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

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

   917 

   956 

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

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

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

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

   921             return v.visitEmptyStatement(this, d);

   961             return v.visitEmptyStatement(this, d);

   922         }

   962         }

   923 

   963 

   924         @Override

   964         @Override

   942             this.flags = flags;

   982             this.flags = flags;

   943         }

   983         }

   944         @Override

   984         @Override

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

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

   946 

   986 

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

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

   948         public List<JCStatement> getStatements() {

   990         public List<JCStatement> getStatements() {

   949             return stats;

   991             return stats;

   950         }

   992         }

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

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

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

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

   954             return v.visitBlock(this, d);

   997             return v.visitBlock(this, d);

   955         }

   998         }

   956 

   999 

   957         @Override

  1000         @Override

   971             this.cond = cond;

  1014             this.cond = cond;

   972         }

  1015         }

   973         @Override

  1016         @Override

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

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

   975 

  1018 

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

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

   977         public JCExpression getCondition() { return cond; }

  1022         public JCExpression getCondition() { return cond; }

   978         public JCStatement getStatement() { return body; }

  1024         public JCStatement getStatement() { return body; }

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

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

   981             return v.visitDoWhileLoop(this, d);

  1027             return v.visitDoWhileLoop(this, d);

   982         }

  1028         }

   983 

  1029 

   984         @Override

  1030         @Override

   998             this.body = body;

  1044             this.body = body;

   999         }

  1045         }

  1000         @Override

  1046         @Override

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

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

  1002 

  1048 

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

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

  1004         public JCExpression getCondition() { return cond; }

  1052         public JCExpression getCondition() { return cond; }

  1005         public JCStatement getStatement() { return body; }

  1054         public JCStatement getStatement() { return body; }

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

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

  1008             return v.visitWhileLoop(this, d);

  1057             return v.visitWhileLoop(this, d);

  1009         }

  1058         }

  1010 

  1059 

  1011         @Override

  1060         @Override

  1033             this.body = body;

  1082             this.body = body;

  1034         }

  1083         }

  1035         @Override

  1084         @Override

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

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

  1037 

  1086 

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

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

  1039         public JCExpression getCondition() { return cond; }

  1090         public JCExpression getCondition() { return cond; }

  1040         public JCStatement getStatement() { return body; }

  1092         public JCStatement getStatement() { return body; }

  1041         public List<JCStatement> getInitializer() {

  1094         public List<JCStatement> getInitializer() {

  1042             return init;

  1095             return init;

  1043         }

  1096         }

  1044         public List<JCExpressionStatement> getUpdate() {

  1098         public List<JCExpressionStatement> getUpdate() {

  1045             return step;

  1099             return step;

  1046         }

  1100         }

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

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

  1049             return v.visitForLoop(this, d);

  1103             return v.visitForLoop(this, d);

  1050         }

  1104         }

  1051 

  1105 

  1052         @Override

  1106         @Override

  1068             this.body = body;

  1122             this.body = body;

  1069         }

  1123         }

  1070         @Override

  1124         @Override

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

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

  1072 

  1126 

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

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

  1074         public JCVariableDecl getVariable() { return var; }

  1130         public JCVariableDecl getVariable() { return var; }

  1075         public JCExpression getExpression() { return expr; }

  1132         public JCExpression getExpression() { return expr; }

  1076         public JCStatement getStatement() { return body; }

  1134         public JCStatement getStatement() { return body; }

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

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

  1079             return v.visitEnhancedForLoop(this, d);

  1137             return v.visitEnhancedForLoop(this, d);

  1080         }

  1138         }

  1081         @Override

  1139         @Override

  1082         public Tag getTag() {

  1140         public Tag getTag() {

  1094             this.label = label;

  1152             this.label = label;

  1095             this.body = body;

  1153             this.body = body;

  1096         }

  1154         }

  1097         @Override

  1155         @Override

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

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

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

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

  1100         public Name getLabel() { return label; }

  1160         public Name getLabel() { return label; }

  1101         public JCStatement getStatement() { return body; }

  1162         public JCStatement getStatement() { return body; }

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

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

  1104             return v.visitLabeledStatement(this, d);

  1165             return v.visitLabeledStatement(this, d);

  1105         }

  1166         }

  1106         @Override

  1167         @Override

  1107         public Tag getTag() {

  1168         public Tag getTag() {

  1120             this.cases = cases;

  1181             this.cases = cases;

  1121         }

  1182         }

  1122         @Override

  1183         @Override

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

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

  1124 

  1185 

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

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

  1126         public JCExpression getExpression() { return selector; }

  1189         public JCExpression getExpression() { return selector; }

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

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

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

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

  1130             return v.visitSwitch(this, d);

  1194             return v.visitSwitch(this, d);

  1131         }

  1195         }

  1132         @Override

  1196         @Override

  1133         public Tag getTag() {

  1197         public Tag getTag() {

  1146             this.stats = stats;

  1210             this.stats = stats;

  1147         }

  1211         }

  1148         @Override

  1212         @Override

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

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

  1150 

  1214 

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

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

  1152         public JCExpression getExpression() { return pat; }

  1218         public JCExpression getExpression() { return pat; }

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

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

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

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

  1156             return v.visitCase(this, d);

  1223             return v.visitCase(this, d);

  1157         }

  1224         }

  1158         @Override

  1225         @Override

  1159         public Tag getTag() {

  1226         public Tag getTag() {

  1172             this.body = body;

  1239             this.body = body;

  1173         }

  1240         }

  1174         @Override

  1241         @Override

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

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

  1176 

  1243 

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

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

  1178         public JCExpression getExpression() { return lock; }

  1247         public JCExpression getExpression() { return lock; }

  1179         public JCBlock getBlock() { return body; }

  1249         public JCBlock getBlock() { return body; }

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

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

  1182             return v.visitSynchronized(this, d);

  1252             return v.visitSynchronized(this, d);

  1183         }

  1253         }

  1184         @Override

  1254         @Override

  1185         public Tag getTag() {

  1255         public Tag getTag() {

  1206             this.resources = resources;

  1276             this.resources = resources;

  1207         }

  1277         }

  1208         @Override

  1278         @Override

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

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

  1210 

  1280 

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

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

  1212         public JCBlock getBlock() { return body; }

  1284         public JCBlock getBlock() { return body; }

  1213         public List<JCCatch> getCatches() {

  1286         public List<JCCatch> getCatches() {

  1214             return catchers;

  1287             return catchers;

  1215         }

  1288         }

  1216         public JCBlock getFinallyBlock() { return finalizer; }

  1290         public JCBlock getFinallyBlock() { return finalizer; }

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

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

  1219             return v.visitTry(this, d);

  1293             return v.visitTry(this, d);

  1220         }

  1294         }

  1222         public List<JCTree> getResources() {

  1296         public List<JCTree> getResources() {

  1223             return resources;

  1297             return resources;

  1224         }

  1298         }

  1225         @Override

  1299         @Override

  1226         public Tag getTag() {

  1300         public Tag getTag() {

  1239             this.body = body;

  1313             this.body = body;

  1240         }

  1314         }

  1241         @Override

  1315         @Override

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

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

  1243 

  1317 

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

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

  1245         public JCVariableDecl getParameter() { return param; }

  1321         public JCVariableDecl getParameter() { return param; }

  1246         public JCBlock getBlock() { return body; }

  1323         public JCBlock getBlock() { return body; }

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

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

  1249             return v.visitCatch(this, d);

  1326             return v.visitCatch(this, d);

  1250         }

  1327         }

  1251         @Override

  1328         @Override

  1252         public Tag getTag() {

  1329         public Tag getTag() {

  1270             this.falsepart = falsepart;

  1347             this.falsepart = falsepart;

  1271         }

  1348         }

  1272         @Override

  1349         @Override

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

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

  1274 

  1351 

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

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

  1276         public JCExpression getCondition() { return cond; }

  1355         public JCExpression getCondition() { return cond; }

  1277         public JCExpression getTrueExpression() { return truepart; }

  1357         public JCExpression getTrueExpression() { return truepart; }

  1278         public JCExpression getFalseExpression() { return falsepart; }

  1359         public JCExpression getFalseExpression() { return falsepart; }

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

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

  1281             return v.visitConditionalExpression(this, d);

  1362             return v.visitConditionalExpression(this, d);

  1282         }

  1363         }

  1283         @Override

  1364         @Override

  1284         public Tag getTag() {

  1365         public Tag getTag() {

  1302             this.elsepart = elsepart;

  1383             this.elsepart = elsepart;

  1303         }

  1384         }

  1304         @Override

  1385         @Override

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

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

  1306 

  1387 

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

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

  1308         public JCExpression getCondition() { return cond; }

  1391         public JCExpression getCondition() { return cond; }

  1309         public JCStatement getThenStatement() { return thenpart; }

  1393         public JCStatement getThenStatement() { return thenpart; }

  1310         public JCStatement getElseStatement() { return elsepart; }

  1395         public JCStatement getElseStatement() { return elsepart; }

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

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

  1313             return v.visitIf(this, d);

  1398             return v.visitIf(this, d);

  1314         }

  1399         }

  1315         @Override

  1400         @Override

  1316         public Tag getTag() {

  1401         public Tag getTag() {

  1329             this.expr = expr;

  1414             this.expr = expr;

  1330         }

  1415         }

  1331         @Override

  1416         @Override

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

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

  1333 

  1418 

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

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

  1335         public JCExpression getExpression() { return expr; }

  1422         public JCExpression getExpression() { return expr; }

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

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

  1338             return v.visitExpressionStatement(this, d);

  1425             return v.visitExpressionStatement(this, d);

  1339         }

  1426         }

  1340         @Override

  1427         @Override

  1341         public Tag getTag() {

  1428         public Tag getTag() {

  1369             this.target = target;

  1456             this.target = target;

  1370         }

  1457         }

  1371         @Override

  1458         @Override

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

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

  1373 

  1460 

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

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

  1375         public Name getLabel() { return label; }

  1464         public Name getLabel() { return label; }

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

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

  1378             return v.visitBreak(this, d);

  1467             return v.visitBreak(this, d);

  1379         }

  1468         }

  1380         @Override

  1469         @Override

  1381         public Tag getTag() {

  1470         public Tag getTag() {

  1394             this.target = target;

  1483             this.target = target;

  1395         }

  1484         }

  1396         @Override

  1485         @Override

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

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

  1398 

  1487 

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

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

  1400         public Name getLabel() { return label; }

  1491         public Name getLabel() { return label; }

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

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

  1403             return v.visitContinue(this, d);

  1494             return v.visitContinue(this, d);

  1404         }

  1495         }

  1405         @Override

  1496         @Override

  1406         public Tag getTag() {

  1497         public Tag getTag() {

  1417             this.expr = expr;

  1508             this.expr = expr;

  1418         }

  1509         }

  1419         @Override

  1510         @Override

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

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

  1421 

  1512 

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

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

  1423         public JCExpression getExpression() { return expr; }

  1516         public JCExpression getExpression() { return expr; }

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

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

  1426             return v.visitReturn(this, d);

  1519             return v.visitReturn(this, d);

  1427         }

  1520         }

  1428         @Override

  1521         @Override

  1429         public Tag getTag() {

  1522         public Tag getTag() {

  1440             this.expr = expr;

  1533             this.expr = expr;

  1441         }

  1534         }

  1442         @Override

  1535         @Override

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

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

  1444 

  1537 

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

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

  1446         public JCExpression getExpression() { return expr; }

  1541         public JCExpression getExpression() { return expr; }

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

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

  1449             return v.visitThrow(this, d);

  1544             return v.visitThrow(this, d);

  1450         }

  1545         }

  1451         @Override

  1546         @Override

  1452         public Tag getTag() {

  1547         public Tag getTag() {

  1465             this.detail = detail;

  1560             this.detail = detail;

  1466         }

  1561         }

  1467         @Override

  1562         @Override

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

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

  1469 

  1564 

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

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

  1471         public JCExpression getCondition() { return cond; }

  1568         public JCExpression getCondition() { return cond; }

  1472         public JCExpression getDetail() { return detail; }

  1570         public JCExpression getDetail() { return detail; }

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

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

  1475             return v.visitAssert(this, d);

  1573             return v.visitAssert(this, d);

  1476         }

  1574         }

  1477         @Override

  1575         @Override

  1478         public Tag getTag() {

  1576         public Tag getTag() {

  1498             this.args = args;

  1596             this.args = args;

  1499         }

  1597         }

  1500         @Override

  1598         @Override

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

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

  1502 

  1600 

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

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

  1504         public List<JCExpression> getTypeArguments() {

  1604         public List<JCExpression> getTypeArguments() {

  1505             return typeargs;

  1605             return typeargs;

  1506         }

  1606         }

  1507         public JCExpression getMethodSelect() { return meth; }

  1608         public JCExpression getMethodSelect() { return meth; }

  1508         public List<JCExpression> getArguments() {

  1610         public List<JCExpression> getArguments() {

  1509             return args;

  1611             return args;

  1510         }

  1612         }

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

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

  1513             return v.visitMethodInvocation(this, d);

  1615             return v.visitMethodInvocation(this, d);

  1514         }

  1616         }

  1515         @Override

  1617         @Override

  1516         public JCMethodInvocation setType(Type type) {

  1618         public JCMethodInvocation setType(Type type) {

  1549             this.def = def;

  1651             this.def = def;

  1550         }

  1652         }

  1551         @Override

  1653         @Override

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

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

  1553 

  1655 

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

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

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

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

  1556             return encl;

  1660             return encl;

  1557         }

  1661         }

  1558         public List<JCExpression> getTypeArguments() {

  1663         public List<JCExpression> getTypeArguments() {

  1559             return typeargs;

  1664             return typeargs;

  1560         }

  1665         }

  1561         public JCExpression getIdentifier() { return clazz; }

  1667         public JCExpression getIdentifier() { return clazz; }

  1562         public List<JCExpression> getArguments() {

  1669         public List<JCExpression> getArguments() {

  1563             return args;

  1670             return args;

  1564         }

  1671         }

  1565         public JCClassDecl getClassBody() { return def; }

  1673         public JCClassDecl getClassBody() { return def; }

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

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

  1568             return v.visitNewClass(this, d);

  1676             return v.visitNewClass(this, d);

  1569         }

  1677         }

  1570         @Override

  1678         @Override

  1571         public Tag getTag() {

  1679         public Tag getTag() {

  1595             this.elems = elems;

  1703             this.elems = elems;

  1596         }

  1704         }

  1597         @Override

  1705         @Override

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

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

  1599 

  1707 

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

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

  1601         public JCExpression getType() { return elemtype; }

  1711         public JCExpression getType() { return elemtype; }

  1602         public List<JCExpression> getDimensions() {

  1713         public List<JCExpression> getDimensions() {

  1603             return dims;

  1714             return dims;

  1604         }

  1715         }

  1605         public List<JCExpression> getInitializers() {

  1717         public List<JCExpression> getInitializers() {

  1606             return elems;

  1718             return elems;

  1607         }

  1719         }

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

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

  1610             return v.visitNewArray(this, d);

  1722             return v.visitNewArray(this, d);

  1611         }

  1723         }

  1612         @Override

  1724         @Override

  1613         public Tag getTag() {

  1725         public Tag getTag() {

  1614             return NEWARRAY;

  1726             return NEWARRAY;

  1615         }

  1727         }

  1616 

  1728 

  1618         public List<JCAnnotation> getAnnotations() {

  1730         public List<JCAnnotation> getAnnotations() {

  1619             return annotations;

  1731             return annotations;

  1620         }

  1732         }

  1621 

  1733 

  1623         public List<List<JCAnnotation>> getDimAnnotations() {

  1735         public List<List<JCAnnotation>> getDimAnnotations() {

  1624             return dimAnnotations;

  1736             return dimAnnotations;

  1625         }

  1737         }

  1626     }

  1738     }

  1627 

  1739 

  1657         }

  1769         }

  1658         @Override

  1770         @Override

  1659         public void accept(Visitor v) {

  1771         public void accept(Visitor v) {

  1660             v.visitLambda(this);

  1772             v.visitLambda(this);

  1661         }

  1773         }

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

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

  1664             return v.visitLambdaExpression(this, d);

  1776             return v.visitLambdaExpression(this, d);

  1665         }

  1777         }

  1666         public Kind getKind() {

  1779         public Kind getKind() {

  1667             return Kind.LAMBDA_EXPRESSION;

  1780             return Kind.LAMBDA_EXPRESSION;

  1668         }

  1781         }

  1669         public JCTree getBody() {

  1783         public JCTree getBody() {

  1670             return body;

  1784             return body;

  1671         }

  1785         }

  1672         public java.util.List<? extends VariableTree> getParameters() {

  1787         public java.util.List<? extends VariableTree> getParameters() {

  1673             return params;

  1788             return params;

  1674         }

  1789         }

  1675         @Override

  1790         @Override

  1676         public JCLambda setType(Type type) {

  1791         public JCLambda setType(Type type) {

  1677             super.setType(type);

  1792             super.setType(type);

  1678             return this;

  1793             return this;

  1679         }

  1794         }

  1681         public BodyKind getBodyKind() {

  1796         public BodyKind getBodyKind() {

  1682             return body.hasTag(BLOCK) ?

  1797             return body.hasTag(BLOCK) ?

  1683                     BodyKind.STATEMENT :

  1798                     BodyKind.STATEMENT :

  1684                     BodyKind.EXPRESSION;

  1799                     BodyKind.EXPRESSION;

  1685         }

  1800         }

  1694             this.expr = expr;

  1809             this.expr = expr;

  1695         }

  1810         }

  1696         @Override

  1811         @Override

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

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

  1698 

  1813 

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

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

  1700         public JCExpression getExpression() { return expr; }

  1817         public JCExpression getExpression() { return expr; }

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

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

  1703             return v.visitParenthesized(this, d);

  1820             return v.visitParenthesized(this, d);

  1704         }

  1821         }

  1705         @Override

  1822         @Override

  1706         public Tag getTag() {

  1823         public Tag getTag() {

  1719             this.rhs = rhs;

  1836             this.rhs = rhs;

  1720         }

  1837         }

  1721         @Override

  1838         @Override

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

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

  1723 

  1840 

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

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

  1725         public JCExpression getVariable() { return lhs; }

  1844         public JCExpression getVariable() { return lhs; }

  1726         public JCExpression getExpression() { return rhs; }

  1846         public JCExpression getExpression() { return rhs; }

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

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

  1729             return v.visitAssignment(this, d);

  1849             return v.visitAssignment(this, d);

  1730         }

  1850         }

  1731         @Override

  1851         @Override

  1732         public Tag getTag() {

  1852         public Tag getTag() {

  1749             this.operator = operator;

  1869             this.operator = operator;

  1750         }

  1870         }

  1751         @Override

  1871         @Override

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

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

  1753 

  1873 

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

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

  1755         public JCExpression getVariable() { return lhs; }

  1877         public JCExpression getVariable() { return lhs; }

  1756         public JCExpression getExpression() { return rhs; }

  1879         public JCExpression getExpression() { return rhs; }

  1757         public Symbol getOperator() {

  1880         public Symbol getOperator() {

  1758             return operator;

  1881             return operator;

  1759         }

  1882         }

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

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

  1762             return v.visitCompoundAssignment(this, d);

  1885             return v.visitCompoundAssignment(this, d);

  1763         }

  1886         }

  1764         @Override

  1887         @Override

  1765         public Tag getTag() {

  1888         public Tag getTag() {

  1779             this.arg = arg;

  1902             this.arg = arg;

  1780         }

  1903         }

  1781         @Override

  1904         @Override

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

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

  1783 

  1906 

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

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

  1785         public JCExpression getExpression() { return arg; }

  1910         public JCExpression getExpression() { return arg; }

  1786         public Symbol getOperator() {

  1911         public Symbol getOperator() {

  1787             return operator;

  1912             return operator;

  1788         }

  1913         }

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

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

  1791             return v.visitUnary(this, d);

  1916             return v.visitUnary(this, d);

  1792         }

  1917         }

  1793         @Override

  1918         @Override

  1794         public Tag getTag() {

  1919         public Tag getTag() {

  1818             this.operator = operator;

  1943             this.operator = operator;

  1819         }

  1944         }

  1820         @Override

  1945         @Override

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

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

  1822 

  1947 

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

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

  1824         public JCExpression getLeftOperand() { return lhs; }

  1951         public JCExpression getLeftOperand() { return lhs; }

  1825         public JCExpression getRightOperand() { return rhs; }

  1953         public JCExpression getRightOperand() { return rhs; }

  1826         public Symbol getOperator() {

  1954         public Symbol getOperator() {

  1827             return operator;

  1955             return operator;

  1828         }

  1956         }

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

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

  1831             return v.visitBinary(this, d);

  1959             return v.visitBinary(this, d);

  1832         }

  1960         }

  1833         @Override

  1961         @Override

  1834         public Tag getTag() {

  1962         public Tag getTag() {

  1847             this.expr = expr;

  1975             this.expr = expr;

  1848         }

  1976         }

  1849         @Override

  1977         @Override

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

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

  1851 

  1979 

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

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

  1853         public JCTree getType() { return clazz; }

  1983         public JCTree getType() { return clazz; }

  1854         public JCExpression getExpression() { return expr; }

  1985         public JCExpression getExpression() { return expr; }

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

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

  1857             return v.visitTypeCast(this, d);

  1988             return v.visitTypeCast(this, d);

  1858         }

  1989         }

  1859         @Override

  1990         @Override

  1860         public Tag getTag() {

  1991         public Tag getTag() {

  1873             this.clazz = clazz;

  2004             this.clazz = clazz;

  1874         }

  2005         }

  1875         @Override

  2006         @Override

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

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

  1877 

  2008 

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

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

  1879         public JCTree getType() { return clazz; }

  2012         public JCTree getType() { return clazz; }

  1880         public JCExpression getExpression() { return expr; }

  2014         public JCExpression getExpression() { return expr; }

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

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

  1883             return v.visitInstanceOf(this, d);

  2017             return v.visitInstanceOf(this, d);

  1884         }

  2018         }

  1885         @Override

  2019         @Override

  1886         public Tag getTag() {

  2020         public Tag getTag() {

  1899             this.index = index;

  2033             this.index = index;

  1900         }

  2034         }

  1901         @Override

  2035         @Override

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

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

  1903 

  2037 

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

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

  1905         public JCExpression getExpression() { return indexed; }

  2041         public JCExpression getExpression() { return indexed; }

  1906         public JCExpression getIndex() { return index; }

  2043         public JCExpression getIndex() { return index; }

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

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

  1909             return v.visitArrayAccess(this, d);

  2046             return v.visitArrayAccess(this, d);

  1910         }

  2047         }

  1911         @Override

  2048         @Override

  1912         public Tag getTag() {

  2049         public Tag getTag() {

  1930             this.sym = sym;

  2067             this.sym = sym;

  1931         }

  2068         }

  1932         @Override

  2069         @Override

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

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

  1934 

  2071 

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

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

  1936         public JCExpression getExpression() { return selected; }

  2075         public JCExpression getExpression() { return selected; }

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

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

  1939             return v.visitMemberSelect(this, d);

  2078             return v.visitMemberSelect(this, d);

  1940         }

  2079         }

  1941         public Name getIdentifier() { return name; }

  2081         public Name getIdentifier() { return name; }

  1942         @Override

  2082         @Override

  1943         public Tag getTag() {

  2083         public Tag getTag() {

  1944             return SELECT;

  2084             return SELECT;

  1945         }

  2085         }

  2006             this.typeargs = typeargs;

  2146             this.typeargs = typeargs;

  2007         }

  2147         }

  2008         @Override

  2148         @Override

  2009         public void accept(Visitor v) { v.visitReference(this); }

  2149         public void accept(Visitor v) { v.visitReference(this); }

  2010 

  2150 

  2011         public Kind getKind() { return Kind.MEMBER_REFERENCE; }

  2152         public Kind getKind() { return Kind.MEMBER_REFERENCE; }

  2013         public ReferenceMode getMode() { return mode; }

  2154         public ReferenceMode getMode() { return mode; }

  2015         public JCExpression getQualifierExpression() { return expr; }

  2156         public JCExpression getQualifierExpression() { return expr; }

  2017         public Name getName() { return name; }

  2158         public Name getName() { return name; }

  2019         public List<JCExpression> getTypeArguments() { return typeargs; }

  2160         public List<JCExpression> getTypeArguments() { return typeargs; }

  2020 

  2161 

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

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

  2023             return v.visitMemberReference(this, d);

  2164             return v.visitMemberReference(this, d);

  2024         }

  2165         }

  2025         @Override

  2166         @Override

  2026         public Tag getTag() {

  2167         public Tag getTag() {

  2044             this.sym = sym;

  2185             this.sym = sym;

  2045         }

  2186         }

  2046         @Override

  2187         @Override

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

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

  2048 

  2189 

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

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

  2050         public Name getName() { return name; }

  2193         public Name getName() { return name; }

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

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

  2053             return v.visitIdentifier(this, d);

  2196             return v.visitIdentifier(this, d);

  2054         }

  2197         }

  2055         @Override

  2198         @Override

  2056         public Tag getTag() {

  2199         public Tag getTag() {

  2070             this.value = value;

  2213             this.value = value;

  2071         }

  2214         }

  2072         @Override

  2215         @Override

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

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

  2074 

  2217 

  2075         public Kind getKind() {

  2219         public Kind getKind() {

  2076             return typetag.getKindLiteral();

  2220             return typetag.getKindLiteral();

  2077         }

  2221         }

  2078 

  2222 

  2079         public Object getValue() {

  2224         public Object getValue() {

  2080             switch (typetag) {

  2225             switch (typetag) {

  2081                 case BOOLEAN:

  2226                 case BOOLEAN:

  2082                     int bi = (Integer) value;

  2227                     int bi = (Integer) value;

  2083                     return (bi != 0);

  2228                     return (bi != 0);

  2089                     return c;

  2234                     return c;

  2090                 default:

  2235                 default:

  2091                     return value;

  2236                     return value;

  2092             }

  2237             }

  2093         }

  2238         }

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

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

  2096             return v.visitLiteral(this, d);

  2241             return v.visitLiteral(this, d);

  2097         }

  2242         }

  2098         @Override

  2243         @Override

  2099         public JCLiteral setType(Type type) {

  2244         public JCLiteral setType(Type type) {

  2117             this.typetag = typetag;

  2262             this.typetag = typetag;

  2118         }

  2263         }

  2119         @Override

  2264         @Override

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

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

  2121 

  2266 

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

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

  2123         public TypeKind getPrimitiveTypeKind() {

  2270         public TypeKind getPrimitiveTypeKind() {

  2124             return typetag.getPrimitiveTypeKind();

  2271             return typetag.getPrimitiveTypeKind();

  2125         }

  2272         }

  2126 

  2273 

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

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

  2129             return v.visitPrimitiveType(this, d);

  2276             return v.visitPrimitiveType(this, d);

  2130         }

  2277         }

  2131         @Override

  2278         @Override

  2132         public Tag getTag() {

  2279         public Tag getTag() {

  2143             this.elemtype = elemtype;

  2290             this.elemtype = elemtype;

  2144         }

  2291         }

  2145         @Override

  2292         @Override

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

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

  2147 

  2294 

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

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

  2149         public JCTree getType() { return elemtype; }

  2298         public JCTree getType() { return elemtype; }

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

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

  2152             return v.visitArrayType(this, d);

  2301             return v.visitArrayType(this, d);

  2153         }

  2302         }

  2154         @Override

  2303         @Override

  2155         public Tag getTag() {

  2304         public Tag getTag() {

  2168             this.arguments = arguments;

  2317             this.arguments = arguments;

  2169         }

  2318         }

  2170         @Override

  2319         @Override

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

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

  2172 

  2321 

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

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

  2174         public JCTree getType() { return clazz; }

  2325         public JCTree getType() { return clazz; }

  2175         public List<JCExpression> getTypeArguments() {

  2327         public List<JCExpression> getTypeArguments() {

  2176             return arguments;

  2328             return arguments;

  2177         }

  2329         }

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

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

  2180             return v.visitParameterizedType(this, d);

  2332             return v.visitParameterizedType(this, d);

  2181         }

  2333         }

  2182         @Override

  2334         @Override

  2183         public Tag getTag() {

  2335         public Tag getTag() {

  2196             this.alternatives = components;

  2348             this.alternatives = components;

  2197         }

  2349         }

  2198         @Override

  2350         @Override

  2199         public void accept(Visitor v) { v.visitTypeUnion(this); }

  2351         public void accept(Visitor v) { v.visitTypeUnion(this); }

  2200 

  2352 

  2201         public Kind getKind() { return Kind.UNION_TYPE; }

  2354         public Kind getKind() { return Kind.UNION_TYPE; }

  2202 

  2355 

  2203         public List<JCExpression> getTypeAlternatives() {

  2357         public List<JCExpression> getTypeAlternatives() {

  2204             return alternatives;

  2358             return alternatives;

  2205         }

  2359         }

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

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

  2208             return v.visitUnionType(this, d);

  2362             return v.visitUnionType(this, d);

  2209         }

  2363         }

  2210         @Override

  2364         @Override

  2211         public Tag getTag() {

  2365         public Tag getTag() {

  2224             this.bounds = bounds;

  2378             this.bounds = bounds;

  2225         }

  2379         }

  2226         @Override

  2380         @Override

  2227         public void accept(Visitor v) { v.visitTypeIntersection(this); }

  2381         public void accept(Visitor v) { v.visitTypeIntersection(this); }

  2228 

  2382 

  2229         public Kind getKind() { return Kind.INTERSECTION_TYPE; }

  2384         public Kind getKind() { return Kind.INTERSECTION_TYPE; }

  2230 

  2385 

  2231         public List<JCExpression> getBounds() {

  2387         public List<JCExpression> getBounds() {

  2232             return bounds;

  2388             return bounds;

  2233         }

  2389         }

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

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

  2236             return v.visitIntersectionType(this, d);

  2392             return v.visitIntersectionType(this, d);

  2237         }

  2393         }

  2238         @Override

  2394         @Override

  2239         public Tag getTag() {

  2395         public Tag getTag() {

  2257             this.annotations = annotations;

  2413             this.annotations = annotations;

  2258         }

  2414         }

  2259         @Override

  2415         @Override

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

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

  2261 

  2417 

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

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

  2263         public Name getName() { return name; }

  2421         public Name getName() { return name; }

  2264         public List<JCExpression> getBounds() {

  2423         public List<JCExpression> getBounds() {

  2265             return bounds;

  2424             return bounds;

  2266         }

  2425         }

  2267         public List<JCAnnotation> getAnnotations() {

  2427         public List<JCAnnotation> getAnnotations() {

  2268             return annotations;

  2428             return annotations;

  2269         }

  2429         }

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

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

  2272             return v.visitTypeParameter(this, d);

  2432             return v.visitTypeParameter(this, d);

  2273         }

  2433         }

  2274         @Override

  2434         @Override

  2275         public Tag getTag() {

  2435         public Tag getTag() {

  2286             this.inner = inner;

  2446             this.inner = inner;

  2287         }

  2447         }

  2288         @Override

  2448         @Override

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

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

  2290 

  2450 

  2291         public Kind getKind() {

  2452         public Kind getKind() {

  2292             switch (kind.kind) {

  2453             switch (kind.kind) {

  2293             case UNBOUND:

  2454             case UNBOUND:

  2294                 return Kind.UNBOUNDED_WILDCARD;

  2455                 return Kind.UNBOUNDED_WILDCARD;

  2295             case EXTENDS:

  2456             case EXTENDS:

  2298                 return Kind.SUPER_WILDCARD;

  2459                 return Kind.SUPER_WILDCARD;

  2299             default:

  2460             default:

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

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

  2301             }

  2462             }

  2302         }

  2463         }

  2303         public JCTree getBound() { return inner; }

  2465         public JCTree getBound() { return inner; }

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

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

  2306             return v.visitWildcard(this, d);

  2468             return v.visitWildcard(this, d);

  2307         }

  2469         }

  2308         @Override

  2470         @Override

  2309         public Tag getTag() {

  2471         public Tag getTag() {

  2317             this.kind = kind;

  2479             this.kind = kind;

  2318         }

  2480         }

  2319         @Override

  2481         @Override

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

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

  2321 

  2483 

  2322         public Kind getKind() {

  2485         public Kind getKind() {

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

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

  2324         }

  2487         }

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

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

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

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

  2328         }

  2491         }

  2329         @Override

  2492         @Override

  2330         public Tag getTag() {

  2493         public Tag getTag() {

  2353         }

  2516         }

  2354 

  2517 

  2355         @Override

  2518         @Override

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

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

  2357 

  2520 

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

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

  2359 

  2523 

  2360         public JCTree getAnnotationType() { return annotationType; }

  2525         public JCTree getAnnotationType() { return annotationType; }

  2361         public List<JCExpression> getArguments() {

  2527         public List<JCExpression> getArguments() {

  2362             return args;

  2528             return args;

  2363         }

  2529         }

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

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

  2366             return v.visitAnnotation(this, d);

  2532             return v.visitAnnotation(this, d);

  2367         }

  2533         }

  2368         @Override

  2534         @Override

  2369         public Tag getTag() {

  2535         public Tag getTag() {

  2379             this.annotations = annotations;

  2545             this.annotations = annotations;

  2380         }

  2546         }

  2381         @Override

  2547         @Override

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

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

  2383 

  2549 

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

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

  2385         public Set<Modifier> getFlags() {

  2553         public Set<Modifier> getFlags() {

  2386             return Flags.asModifierSet(flags);

  2554             return Flags.asModifierSet(flags);

  2387         }

  2555         }

  2388         public List<JCAnnotation> getAnnotations() {

  2557         public List<JCAnnotation> getAnnotations() {

  2389             return annotations;

  2558             return annotations;

  2390         }

  2559         }

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

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

  2393             return v.visitModifiers(this, d);

  2562             return v.visitModifiers(this, d);

  2394         }

  2563         }

  2395         @Override

  2564         @Override

  2396         public Tag getTag() {

  2565         public Tag getTag() {

  2409             this.underlyingType = underlyingType;

  2578             this.underlyingType = underlyingType;

  2410         }

  2579         }

  2411         @Override

  2580         @Override

  2412         public void accept(Visitor v) { v.visitAnnotatedType(this); }

  2581         public void accept(Visitor v) { v.visitAnnotatedType(this); }

  2413 

  2582 

  2414         public Kind getKind() { return Kind.ANNOTATED_TYPE; }

  2584         public Kind getKind() { return Kind.ANNOTATED_TYPE; }

  2415         public List<JCAnnotation> getAnnotations() {

  2586         public List<JCAnnotation> getAnnotations() {

  2416             return annotations;

  2587             return annotations;

  2417         }

  2588         }

  2418         public JCExpression getUnderlyingType() {

  2590         public JCExpression getUnderlyingType() {

  2419             return underlyingType;

  2591             return underlyingType;

  2420         }