116 /** Variable definitions, of type VarDef.
117 */
118 VARDEF,
119
120 /** The no-op statement ";", of type Skip
121 */
122 SKIP,
123
124 /** Blocks, of type Block.
125 */
126 BLOCK,
127
128 /** Do-while loops, of type DoLoop.
129 */
130 DOLOOP,
131
132 /** While-loops, of type WhileLoop.
133 */
134 WHILELOOP,
135
136 /** For-loops, of type ForLoop.
137 */
138 FORLOOP,
139
140 /** Foreach-loops, of type ForeachLoop.
141 */
142 FOREACHLOOP,
143
144 /** Labelled statements, of type Labelled.
145 */
146 LABELLED,
147
148 /** Switch statements, of type Switch.
149 */
150 SWITCH,
151
152 /** Case parts in switch statements/expressions, of type Case.
153 */
154 CASE,
155
240 /** Patterns.
241 */
242 ANYPATTERN,
243 BINDINGPATTERN,
244 RECORDPATTERN,
245
246 /* Case labels.
247 */
248 DEFAULTCASELABEL,
249 CONSTANTCASELABEL,
250 PATTERNCASELABEL,
251
252 /** Indexed array expressions, of type Indexed.
253 */
254 INDEXED,
255
256 /** Selections, of type Select.
257 */
258 SELECT,
259
260 /** Member references, of type Reference.
261 */
262 REFERENCE,
263
264 /** Simple identifiers, of type Ident.
265 */
266 IDENT,
267
268 /** Literals, of type Literal.
269 */
270 LITERAL,
271
272 /** String template expression.
273 */
274 STRING_TEMPLATE,
275
276 /** Basic type identifiers, of type TypeIdent.
277 */
278 TYPEIDENT,
279
868 /** method modifiers */
869 public JCModifiers mods;
870 /** method name */
871 public Name name;
872 /** type of method return value */
873 public JCExpression restype;
874 /** type parameters */
875 public List<JCTypeParameter> typarams;
876 /** receiver parameter */
877 public JCVariableDecl recvparam;
878 /** value parameters */
879 public List<JCVariableDecl> params;
880 /** exceptions thrown by this method */
881 public List<JCExpression> thrown;
882 /** statements in the method */
883 public JCBlock body;
884 /** default value, for annotation types */
885 public JCExpression defaultValue;
886 /** method symbol */
887 public MethodSymbol sym;
888 /** does this method completes normally */
889 public boolean completesNormally;
890
891 protected JCMethodDecl(JCModifiers mods,
892 Name name,
893 JCExpression restype,
894 List<JCTypeParameter> typarams,
895 JCVariableDecl recvparam,
896 List<JCVariableDecl> params,
897 List<JCExpression> thrown,
898 JCBlock body,
899 JCExpression defaultValue,
900 MethodSymbol sym)
901 {
902 this.mods = mods;
903 this.name = name;
904 this.restype = restype;
905 this.typarams = typarams;
906 this.params = params;
907 this.recvparam = recvparam;
935 public JCVariableDecl getReceiverParameter() { return recvparam; }
936 @DefinedBy(Api.COMPILER_TREE)
937 public List<JCExpression> getThrows() {
938 return thrown;
939 }
940 @DefinedBy(Api.COMPILER_TREE)
941 public JCBlock getBody() { return body; }
942 @DefinedBy(Api.COMPILER_TREE)
943 public JCTree getDefaultValue() { // for annotation types
944 return defaultValue;
945 }
946 @Override @DefinedBy(Api.COMPILER_TREE)
947 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
948 return v.visitMethod(this, d);
949 }
950
951 @Override
952 public Tag getTag() {
953 return METHODDEF;
954 }
955 }
956
957 /**
958 * A variable definition.
959 */
960 public static class JCVariableDecl extends JCStatement implements VariableTree {
961 /** variable modifiers */
962 public JCModifiers mods;
963 /** variable name */
964 public Name name;
965 /** variable name expression */
966 public JCExpression nameexpr;
967 /** type of the variable */
968 public JCExpression vartype;
969 /** variable's initial value */
970 public JCExpression init;
971 /** symbol */
972 public VarSymbol sym;
973 /** explicit start pos */
974 public int startPos = Position.NOPOS;
1155 @Override
1156 public void accept(Visitor v) { v.visitWhileLoop(this); }
1157
1158 @DefinedBy(Api.COMPILER_TREE)
1159 public Kind getKind() { return Kind.WHILE_LOOP; }
1160 @DefinedBy(Api.COMPILER_TREE)
1161 public JCExpression getCondition() { return cond; }
1162 @DefinedBy(Api.COMPILER_TREE)
1163 public JCStatement getStatement() { return body; }
1164 @Override @DefinedBy(Api.COMPILER_TREE)
1165 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1166 return v.visitWhileLoop(this, d);
1167 }
1168
1169 @Override
1170 public Tag getTag() {
1171 return WHILELOOP;
1172 }
1173 }
1174
1175 /**
1176 * A for loop.
1177 */
1178 public static class JCForLoop extends JCStatement implements ForLoopTree {
1179 public List<JCStatement> init;
1180 public JCExpression cond;
1181 public List<JCExpressionStatement> step;
1182 public JCStatement body;
1183 protected JCForLoop(List<JCStatement> init,
1184 JCExpression cond,
1185 List<JCExpressionStatement> update,
1186 JCStatement body)
1187 {
1188 this.init = init;
1189 this.cond = cond;
1190 this.step = update;
1191 this.body = body;
1192 }
1193 @Override
1194 public void accept(Visitor v) { v.visitForLoop(this); }
1362 @Override @DefinedBy(Api.COMPILER_TREE)
1363 public List<JCStatement> getStatements() {
1364 return caseKind == CaseKind.STATEMENT ? stats : null;
1365 }
1366 @Override @DefinedBy(Api.COMPILER_TREE)
1367 public JCTree getBody() { return body; }
1368 @Override @DefinedBy(Api.COMPILER_TREE)
1369 public CaseKind getCaseKind() {
1370 return caseKind;
1371 }
1372 @Override @DefinedBy(Api.COMPILER_TREE)
1373 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1374 return v.visitCase(this, d);
1375 }
1376 @Override
1377 public Tag getTag() {
1378 return CASE;
1379 }
1380 }
1381
1382 /**
1383 * A "switch ( ) { }" construction.
1384 */
1385 public static class JCSwitchExpression extends JCPolyExpression implements SwitchExpressionTree {
1386 public JCExpression selector;
1387 public List<JCCase> cases;
1388 /** Position of closing brace, optional. */
1389 public int endpos = Position.NOPOS;
1390 public boolean hasUnconditionalPattern;
1391 public boolean isExhaustive;
1392 public boolean patternSwitch;
1393 public boolean wasEnumSelector;
1394 protected JCSwitchExpression(JCExpression selector, List<JCCase> cases) {
1395 this.selector = selector;
1396 this.cases = cases;
1397 }
1398 @Override
1399 public void accept(Visitor v) { v.visitSwitchExpression(this); }
1400
1401 @DefinedBy(Api.COMPILER_TREE)
3454 JCBlock body,
3455 JCExpression defaultValue);
3456 JCVariableDecl VarDef(JCModifiers mods,
3457 Name name,
3458 JCExpression vartype,
3459 JCExpression init);
3460 JCSkip Skip();
3461 JCBlock Block(long flags, List<JCStatement> stats);
3462 JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);
3463 JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);
3464 JCForLoop ForLoop(List<JCStatement> init,
3465 JCExpression cond,
3466 List<JCExpressionStatement> step,
3467 JCStatement body);
3468 JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
3469 JCLabeledStatement Labelled(Name label, JCStatement body);
3470 JCSwitch Switch(JCExpression selector, List<JCCase> cases);
3471 JCSwitchExpression SwitchExpression(JCExpression selector, List<JCCase> cases);
3472 JCCase Case(CaseTree.CaseKind caseKind, List<JCCaseLabel> labels, JCExpression guard,
3473 List<JCStatement> stats, JCTree body);
3474 JCSynchronized Synchronized(JCExpression lock, JCBlock body);
3475 JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);
3476 JCTry Try(List<JCTree> resources,
3477 JCBlock body,
3478 List<JCCatch> catchers,
3479 JCBlock finalizer);
3480 JCCatch Catch(JCVariableDecl param, JCBlock body);
3481 JCConditional Conditional(JCExpression cond,
3482 JCExpression thenpart,
3483 JCExpression elsepart);
3484 JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
3485 JCExpressionStatement Exec(JCExpression expr);
3486 JCBreak Break(Name label);
3487 JCYield Yield(JCExpression value);
3488 JCContinue Continue(Name label);
3489 JCReturn Return(JCExpression expr);
3490 JCThrow Throw(JCExpression expr);
3491 JCAssert Assert(JCExpression cond, JCExpression detail);
3492 JCMethodInvocation Apply(List<JCExpression> typeargs,
3493 JCExpression fn,
3529 JCOpens Opens(JCExpression qualId, List<JCExpression> moduleNames);
3530 JCProvides Provides(JCExpression serviceName, List<JCExpression> implNames);
3531 JCRequires Requires(boolean isTransitive, boolean isStaticPhase, JCExpression qualId);
3532 JCUses Uses(JCExpression qualId);
3533 LetExpr LetExpr(List<JCStatement> defs, JCExpression expr);
3534 }
3535
3536 /** A generic visitor class for trees.
3537 */
3538 public abstract static class Visitor {
3539 public void visitTopLevel(JCCompilationUnit that) { visitTree(that); }
3540 public void visitPackageDef(JCPackageDecl that) { visitTree(that); }
3541 public void visitImport(JCImport that) { visitTree(that); }
3542 public void visitClassDef(JCClassDecl that) { visitTree(that); }
3543 public void visitMethodDef(JCMethodDecl that) { visitTree(that); }
3544 public void visitVarDef(JCVariableDecl that) { visitTree(that); }
3545 public void visitSkip(JCSkip that) { visitTree(that); }
3546 public void visitBlock(JCBlock that) { visitTree(that); }
3547 public void visitDoLoop(JCDoWhileLoop that) { visitTree(that); }
3548 public void visitWhileLoop(JCWhileLoop that) { visitTree(that); }
3549 public void visitForLoop(JCForLoop that) { visitTree(that); }
3550 public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
3551 public void visitLabelled(JCLabeledStatement that) { visitTree(that); }
3552 public void visitSwitch(JCSwitch that) { visitTree(that); }
3553 public void visitCase(JCCase that) { visitTree(that); }
3554 public void visitSwitchExpression(JCSwitchExpression that) { visitTree(that); }
3555 public void visitSynchronized(JCSynchronized that) { visitTree(that); }
3556 public void visitTry(JCTry that) { visitTree(that); }
3557 public void visitCatch(JCCatch that) { visitTree(that); }
3558 public void visitConditional(JCConditional that) { visitTree(that); }
3559 public void visitIf(JCIf that) { visitTree(that); }
3560 public void visitExec(JCExpressionStatement that) { visitTree(that); }
3561 public void visitBreak(JCBreak that) { visitTree(that); }
3562 public void visitYield(JCYield that) { visitTree(that); }
3563 public void visitContinue(JCContinue that) { visitTree(that); }
3564 public void visitReturn(JCReturn that) { visitTree(that); }
3565 public void visitThrow(JCThrow that) { visitTree(that); }
3566 public void visitAssert(JCAssert that) { visitTree(that); }
3567 public void visitApply(JCMethodInvocation that) { visitTree(that); }
3568 public void visitNewClass(JCNewClass that) { visitTree(that); }
3569 public void visitNewArray(JCNewArray that) { visitTree(that); }
3570 public void visitLambda(JCLambda that) { visitTree(that); }
3571 public void visitParens(JCParens that) { visitTree(that); }
3572 public void visitAssign(JCAssign that) { visitTree(that); }
3573 public void visitAssignop(JCAssignOp that) { visitTree(that); }
|
116 /** Variable definitions, of type VarDef.
117 */
118 VARDEF,
119
120 /** The no-op statement ";", of type Skip
121 */
122 SKIP,
123
124 /** Blocks, of type Block.
125 */
126 BLOCK,
127
128 /** Do-while loops, of type DoLoop.
129 */
130 DOLOOP,
131
132 /** While-loops, of type WhileLoop.
133 */
134 WHILELOOP,
135
136 /** Withfields, of type WithField.
137 */
138 WITHFIELD,
139
140 /** For-loops, of type ForLoop.
141 */
142 FORLOOP,
143
144 /** Foreach-loops, of type ForeachLoop.
145 */
146 FOREACHLOOP,
147
148 /** Labelled statements, of type Labelled.
149 */
150 LABELLED,
151
152 /** Switch statements, of type Switch.
153 */
154 SWITCH,
155
156 /** Case parts in switch statements/expressions, of type Case.
157 */
158 CASE,
159
244 /** Patterns.
245 */
246 ANYPATTERN,
247 BINDINGPATTERN,
248 RECORDPATTERN,
249
250 /* Case labels.
251 */
252 DEFAULTCASELABEL,
253 CONSTANTCASELABEL,
254 PATTERNCASELABEL,
255
256 /** Indexed array expressions, of type Indexed.
257 */
258 INDEXED,
259
260 /** Selections, of type Select.
261 */
262 SELECT,
263
264 /** Default values, of type DefaultValueTree.
265 */
266 DEFAULT_VALUE,
267
268 /** Member references, of type Reference.
269 */
270 REFERENCE,
271
272 /** Simple identifiers, of type Ident.
273 */
274 IDENT,
275
276 /** Literals, of type Literal.
277 */
278 LITERAL,
279
280 /** String template expression.
281 */
282 STRING_TEMPLATE,
283
284 /** Basic type identifiers, of type TypeIdent.
285 */
286 TYPEIDENT,
287
876 /** method modifiers */
877 public JCModifiers mods;
878 /** method name */
879 public Name name;
880 /** type of method return value */
881 public JCExpression restype;
882 /** type parameters */
883 public List<JCTypeParameter> typarams;
884 /** receiver parameter */
885 public JCVariableDecl recvparam;
886 /** value parameters */
887 public List<JCVariableDecl> params;
888 /** exceptions thrown by this method */
889 public List<JCExpression> thrown;
890 /** statements in the method */
891 public JCBlock body;
892 /** default value, for annotation types */
893 public JCExpression defaultValue;
894 /** method symbol */
895 public MethodSymbol sym;
896 /** nascent value that evolves into the return value for a value factory */
897 public VarSymbol factoryProduct;
898
899 /** does this method completes normally */
900 public boolean completesNormally;
901
902 protected JCMethodDecl(JCModifiers mods,
903 Name name,
904 JCExpression restype,
905 List<JCTypeParameter> typarams,
906 JCVariableDecl recvparam,
907 List<JCVariableDecl> params,
908 List<JCExpression> thrown,
909 JCBlock body,
910 JCExpression defaultValue,
911 MethodSymbol sym)
912 {
913 this.mods = mods;
914 this.name = name;
915 this.restype = restype;
916 this.typarams = typarams;
917 this.params = params;
918 this.recvparam = recvparam;
946 public JCVariableDecl getReceiverParameter() { return recvparam; }
947 @DefinedBy(Api.COMPILER_TREE)
948 public List<JCExpression> getThrows() {
949 return thrown;
950 }
951 @DefinedBy(Api.COMPILER_TREE)
952 public JCBlock getBody() { return body; }
953 @DefinedBy(Api.COMPILER_TREE)
954 public JCTree getDefaultValue() { // for annotation types
955 return defaultValue;
956 }
957 @Override @DefinedBy(Api.COMPILER_TREE)
958 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
959 return v.visitMethod(this, d);
960 }
961
962 @Override
963 public Tag getTag() {
964 return METHODDEF;
965 }
966
967 public boolean isInitOrVNew() {
968 return name.table.names.isInitOrVNew(name);
969 }
970 }
971
972 /**
973 * A variable definition.
974 */
975 public static class JCVariableDecl extends JCStatement implements VariableTree {
976 /** variable modifiers */
977 public JCModifiers mods;
978 /** variable name */
979 public Name name;
980 /** variable name expression */
981 public JCExpression nameexpr;
982 /** type of the variable */
983 public JCExpression vartype;
984 /** variable's initial value */
985 public JCExpression init;
986 /** symbol */
987 public VarSymbol sym;
988 /** explicit start pos */
989 public int startPos = Position.NOPOS;
1170 @Override
1171 public void accept(Visitor v) { v.visitWhileLoop(this); }
1172
1173 @DefinedBy(Api.COMPILER_TREE)
1174 public Kind getKind() { return Kind.WHILE_LOOP; }
1175 @DefinedBy(Api.COMPILER_TREE)
1176 public JCExpression getCondition() { return cond; }
1177 @DefinedBy(Api.COMPILER_TREE)
1178 public JCStatement getStatement() { return body; }
1179 @Override @DefinedBy(Api.COMPILER_TREE)
1180 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1181 return v.visitWhileLoop(this, d);
1182 }
1183
1184 @Override
1185 public Tag getTag() {
1186 return WHILELOOP;
1187 }
1188 }
1189
1190 /**
1191 * A withfield expression
1192 */
1193 public static class JCWithField extends JCExpression implements WithFieldTree {
1194 public JCExpression field;
1195 public JCExpression value;
1196 protected JCWithField(JCExpression field, JCExpression value) {
1197 this.field = field;
1198 this.value = value;
1199 }
1200 @Override
1201 public void accept(Visitor v) { v.visitWithField(this); }
1202
1203 @DefinedBy(Api.COMPILER_TREE)
1204 public Kind getKind() { return Kind.WITH_FIELD; }
1205 @DefinedBy(Api.COMPILER_TREE)
1206 public JCExpression getField() { return field; }
1207 @DefinedBy(Api.COMPILER_TREE)
1208 public JCExpression getValue() { return value; }
1209 @Override @DefinedBy(Api.COMPILER_TREE)
1210 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1211 return v.visitWithField(this, d);
1212 }
1213
1214 @Override
1215 public Tag getTag() {
1216 return WITHFIELD;
1217 }
1218 }
1219
1220 /**
1221 * A for loop.
1222 */
1223 public static class JCForLoop extends JCStatement implements ForLoopTree {
1224 public List<JCStatement> init;
1225 public JCExpression cond;
1226 public List<JCExpressionStatement> step;
1227 public JCStatement body;
1228 protected JCForLoop(List<JCStatement> init,
1229 JCExpression cond,
1230 List<JCExpressionStatement> update,
1231 JCStatement body)
1232 {
1233 this.init = init;
1234 this.cond = cond;
1235 this.step = update;
1236 this.body = body;
1237 }
1238 @Override
1239 public void accept(Visitor v) { v.visitForLoop(this); }
1407 @Override @DefinedBy(Api.COMPILER_TREE)
1408 public List<JCStatement> getStatements() {
1409 return caseKind == CaseKind.STATEMENT ? stats : null;
1410 }
1411 @Override @DefinedBy(Api.COMPILER_TREE)
1412 public JCTree getBody() { return body; }
1413 @Override @DefinedBy(Api.COMPILER_TREE)
1414 public CaseKind getCaseKind() {
1415 return caseKind;
1416 }
1417 @Override @DefinedBy(Api.COMPILER_TREE)
1418 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1419 return v.visitCase(this, d);
1420 }
1421 @Override
1422 public Tag getTag() {
1423 return CASE;
1424 }
1425 }
1426
1427 /**
1428 * A "Identifier<TA1, TA2>.default" construction.
1429 */
1430 public static class JCDefaultValue extends JCPolyExpression implements DefaultValueTree {
1431 public JCExpression clazz;
1432
1433 protected JCDefaultValue(JCExpression clazz) {
1434 this.clazz = clazz;
1435 }
1436 @Override
1437 public void accept(Visitor v) { v.visitDefaultValue(this); }
1438
1439 @DefinedBy(Api.COMPILER_TREE)
1440 public Kind getKind() { return Kind.DEFAULT_VALUE; }
1441 @Override @DefinedBy(Api.COMPILER_TREE)
1442 public JCExpression getType() { return clazz; }
1443 @Override @DefinedBy(Api.COMPILER_TREE)
1444 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1445 return v.visitDefaultValue(this, d);
1446 }
1447 @Override
1448 public Tag getTag() {
1449 return DEFAULT_VALUE;
1450 }
1451 }
1452
1453 /**
1454 * A "switch ( ) { }" construction.
1455 */
1456 public static class JCSwitchExpression extends JCPolyExpression implements SwitchExpressionTree {
1457 public JCExpression selector;
1458 public List<JCCase> cases;
1459 /** Position of closing brace, optional. */
1460 public int endpos = Position.NOPOS;
1461 public boolean hasUnconditionalPattern;
1462 public boolean isExhaustive;
1463 public boolean patternSwitch;
1464 public boolean wasEnumSelector;
1465 protected JCSwitchExpression(JCExpression selector, List<JCCase> cases) {
1466 this.selector = selector;
1467 this.cases = cases;
1468 }
1469 @Override
1470 public void accept(Visitor v) { v.visitSwitchExpression(this); }
1471
1472 @DefinedBy(Api.COMPILER_TREE)
3525 JCBlock body,
3526 JCExpression defaultValue);
3527 JCVariableDecl VarDef(JCModifiers mods,
3528 Name name,
3529 JCExpression vartype,
3530 JCExpression init);
3531 JCSkip Skip();
3532 JCBlock Block(long flags, List<JCStatement> stats);
3533 JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);
3534 JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);
3535 JCForLoop ForLoop(List<JCStatement> init,
3536 JCExpression cond,
3537 List<JCExpressionStatement> step,
3538 JCStatement body);
3539 JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
3540 JCLabeledStatement Labelled(Name label, JCStatement body);
3541 JCSwitch Switch(JCExpression selector, List<JCCase> cases);
3542 JCSwitchExpression SwitchExpression(JCExpression selector, List<JCCase> cases);
3543 JCCase Case(CaseTree.CaseKind caseKind, List<JCCaseLabel> labels, JCExpression guard,
3544 List<JCStatement> stats, JCTree body);
3545 JCDefaultValue DefaultValue(JCExpression type);
3546 JCSynchronized Synchronized(JCExpression lock, JCBlock body);
3547 JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);
3548 JCTry Try(List<JCTree> resources,
3549 JCBlock body,
3550 List<JCCatch> catchers,
3551 JCBlock finalizer);
3552 JCCatch Catch(JCVariableDecl param, JCBlock body);
3553 JCConditional Conditional(JCExpression cond,
3554 JCExpression thenpart,
3555 JCExpression elsepart);
3556 JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
3557 JCExpressionStatement Exec(JCExpression expr);
3558 JCBreak Break(Name label);
3559 JCYield Yield(JCExpression value);
3560 JCContinue Continue(Name label);
3561 JCReturn Return(JCExpression expr);
3562 JCThrow Throw(JCExpression expr);
3563 JCAssert Assert(JCExpression cond, JCExpression detail);
3564 JCMethodInvocation Apply(List<JCExpression> typeargs,
3565 JCExpression fn,
3601 JCOpens Opens(JCExpression qualId, List<JCExpression> moduleNames);
3602 JCProvides Provides(JCExpression serviceName, List<JCExpression> implNames);
3603 JCRequires Requires(boolean isTransitive, boolean isStaticPhase, JCExpression qualId);
3604 JCUses Uses(JCExpression qualId);
3605 LetExpr LetExpr(List<JCStatement> defs, JCExpression expr);
3606 }
3607
3608 /** A generic visitor class for trees.
3609 */
3610 public abstract static class Visitor {
3611 public void visitTopLevel(JCCompilationUnit that) { visitTree(that); }
3612 public void visitPackageDef(JCPackageDecl that) { visitTree(that); }
3613 public void visitImport(JCImport that) { visitTree(that); }
3614 public void visitClassDef(JCClassDecl that) { visitTree(that); }
3615 public void visitMethodDef(JCMethodDecl that) { visitTree(that); }
3616 public void visitVarDef(JCVariableDecl that) { visitTree(that); }
3617 public void visitSkip(JCSkip that) { visitTree(that); }
3618 public void visitBlock(JCBlock that) { visitTree(that); }
3619 public void visitDoLoop(JCDoWhileLoop that) { visitTree(that); }
3620 public void visitWhileLoop(JCWhileLoop that) { visitTree(that); }
3621 public void visitWithField(JCWithField that) { visitTree(that); }
3622 public void visitForLoop(JCForLoop that) { visitTree(that); }
3623 public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
3624 public void visitLabelled(JCLabeledStatement that) { visitTree(that); }
3625 public void visitSwitch(JCSwitch that) { visitTree(that); }
3626 public void visitCase(JCCase that) { visitTree(that); }
3627 public void visitDefaultValue(JCDefaultValue that) { visitTree(that); }
3628 public void visitSwitchExpression(JCSwitchExpression that) { visitTree(that); }
3629 public void visitSynchronized(JCSynchronized that) { visitTree(that); }
3630 public void visitTry(JCTry that) { visitTree(that); }
3631 public void visitCatch(JCCatch that) { visitTree(that); }
3632 public void visitConditional(JCConditional that) { visitTree(that); }
3633 public void visitIf(JCIf that) { visitTree(that); }
3634 public void visitExec(JCExpressionStatement that) { visitTree(that); }
3635 public void visitBreak(JCBreak that) { visitTree(that); }
3636 public void visitYield(JCYield that) { visitTree(that); }
3637 public void visitContinue(JCContinue that) { visitTree(that); }
3638 public void visitReturn(JCReturn that) { visitTree(that); }
3639 public void visitThrow(JCThrow that) { visitTree(that); }
3640 public void visitAssert(JCAssert that) { visitTree(that); }
3641 public void visitApply(JCMethodInvocation that) { visitTree(that); }
3642 public void visitNewClass(JCNewClass that) { visitTree(that); }
3643 public void visitNewArray(JCNewArray that) { visitTree(that); }
3644 public void visitLambda(JCLambda that) { visitTree(that); }
3645 public void visitParens(JCParens that) { visitTree(that); }
3646 public void visitAssign(JCAssign that) { visitTree(that); }
3647 public void visitAssignop(JCAssignOp that) { visitTree(that); }
|