< prev index next >

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

Print this page

 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); }
< prev index next >