< 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 

 235 
 236         /** Type test expressions, of type TypeTest.
 237          */
 238         TYPETEST,
 239 
 240         /** Patterns.
 241          */
 242         BINDINGPATTERN,
 243         DEFAULTCASELABEL,
 244         GUARDPATTERN,
 245         PARENTHESIZEDPATTERN,
 246 
 247         /** Indexed array expressions, of type Indexed.
 248          */
 249         INDEXED,
 250 
 251         /** Selections, of type Select.
 252          */
 253         SELECT,
 254 




 255         /** Member references, of type Reference.
 256          */
 257         REFERENCE,
 258 
 259         /** Simple identifiers, of type Ident.
 260          */
 261         IDENT,
 262 
 263         /** Literals, of type Literal.
 264          */
 265         LITERAL,
 266 
 267         /** Basic type identifiers, of type TypeIdent.
 268          */
 269         TYPEIDENT,
 270 
 271         /** Array types, of type TypeArray.
 272          */
 273         TYPEARRAY,
 274 

 704 
 705     public abstract static class JCCaseLabel extends JCTree implements CaseLabelTree {
 706         public abstract boolean isExpression();
 707         public boolean isNullPattern() {
 708             return isExpression() && TreeInfo.isNull((JCExpression) this);
 709         }
 710         public abstract boolean isPattern();
 711     }
 712 
 713     public abstract static class JCExpression extends JCCaseLabel implements ExpressionTree {
 714         @Override
 715         public JCExpression setType(Type type) {
 716             super.setType(type);
 717             return this;
 718         }
 719         @Override
 720         public JCExpression setPos(int pos) {
 721             super.setPos(pos);
 722             return this;
 723         }
 724 
 725         public boolean isPoly() { return false; }
 726         public boolean isStandalone() { return true; }
 727 
 728         @Override
 729         public boolean isExpression() {
 730             return true;
 731         }
 732 
 733         @Override
 734         public boolean isPattern() {
 735             return false;
 736         }
 737     }
 738 
 739     /**
 740      * Common supertype for all poly expression trees (lambda, method references,
 741      * conditionals, method and constructor calls)
 742      */
 743     public abstract static class JCPolyExpression extends JCExpression {
 744 

 873         /** method modifiers */
 874         public JCModifiers mods;
 875         /** method name */
 876         public Name name;
 877         /** type of method return value */
 878         public JCExpression restype;
 879         /** type parameters */
 880         public List<JCTypeParameter> typarams;
 881         /** receiver parameter */
 882         public JCVariableDecl recvparam;
 883         /** value parameters */
 884         public List<JCVariableDecl> params;
 885         /** exceptions thrown by this method */
 886         public List<JCExpression> thrown;
 887         /** statements in the method */
 888         public JCBlock body;
 889         /** default value, for annotation types */
 890         public JCExpression defaultValue;
 891         /** method symbol */
 892         public MethodSymbol sym;



 893         /** does this method completes normally */
 894         public boolean completesNormally;
 895 
 896         protected JCMethodDecl(JCModifiers mods,
 897                             Name name,
 898                             JCExpression restype,
 899                             List<JCTypeParameter> typarams,
 900                             JCVariableDecl recvparam,
 901                             List<JCVariableDecl> params,
 902                             List<JCExpression> thrown,
 903                             JCBlock body,
 904                             JCExpression defaultValue,
 905                             MethodSymbol sym)
 906         {
 907             this.mods = mods;
 908             this.name = name;
 909             this.restype = restype;
 910             this.typarams = typarams;
 911             this.params = params;
 912             this.recvparam = recvparam;

1152         @Override
1153         public void accept(Visitor v) { v.visitWhileLoop(this); }
1154 
1155         @DefinedBy(Api.COMPILER_TREE)
1156         public Kind getKind() { return Kind.WHILE_LOOP; }
1157         @DefinedBy(Api.COMPILER_TREE)
1158         public JCExpression getCondition() { return cond; }
1159         @DefinedBy(Api.COMPILER_TREE)
1160         public JCStatement getStatement() { return body; }
1161         @Override @DefinedBy(Api.COMPILER_TREE)
1162         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1163             return v.visitWhileLoop(this, d);
1164         }
1165 
1166         @Override
1167         public Tag getTag() {
1168             return WHILELOOP;
1169         }
1170     }
1171 






























1172     /**
1173      * A for loop.
1174      */
1175     public static class JCForLoop extends JCStatement implements ForLoopTree {
1176         public List<JCStatement> init;
1177         public JCExpression cond;
1178         public List<JCExpressionStatement> step;
1179         public JCStatement body;
1180         protected JCForLoop(List<JCStatement> init,
1181                           JCExpression cond,
1182                           List<JCExpressionStatement> update,
1183                           JCStatement body)
1184         {
1185             this.init = init;
1186             this.cond = cond;
1187             this.step = update;
1188             this.body = body;
1189         }
1190         @Override
1191         public void accept(Visitor v) { v.visitForLoop(this); }

1346         @Override @DefinedBy(Api.COMPILER_TREE)
1347         public List<JCStatement> getStatements() {
1348             return caseKind == CaseKind.STATEMENT ? stats : null;
1349         }
1350         @Override @DefinedBy(Api.COMPILER_TREE)
1351         public JCTree getBody() { return body; }
1352         @Override @DefinedBy(Api.COMPILER_TREE)
1353         public CaseKind getCaseKind() {
1354             return caseKind;
1355         }
1356         @Override @DefinedBy(Api.COMPILER_TREE)
1357         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1358             return v.visitCase(this, d);
1359         }
1360         @Override
1361         public Tag getTag() {
1362             return CASE;
1363         }
1364     }
1365 


























1366     /**
1367      * A "switch ( ) { }" construction.
1368      */
1369     public static class JCSwitchExpression extends JCPolyExpression implements SwitchExpressionTree {
1370         public JCExpression selector;
1371         public List<JCCase> cases;
1372         /** Position of closing brace, optional. */
1373         public int endpos = Position.NOPOS;
1374         public boolean hasTotalPattern;
1375         public boolean isExhaustive;
1376         public boolean patternSwitch;
1377         protected JCSwitchExpression(JCExpression selector, List<JCCase> cases) {
1378             this.selector = selector;
1379             this.cases = cases;
1380         }
1381         @Override
1382         public void accept(Visitor v) { v.visitSwitchExpression(this); }
1383 
1384         @DefinedBy(Api.COMPILER_TREE)
1385         public Kind getKind() { return Kind.SWITCH_EXPRESSION; }

3325                             JCBlock body,
3326                             JCExpression defaultValue);
3327         JCVariableDecl VarDef(JCModifiers mods,
3328                       Name name,
3329                       JCExpression vartype,
3330                       JCExpression init);
3331         JCSkip Skip();
3332         JCBlock Block(long flags, List<JCStatement> stats);
3333         JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);
3334         JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);
3335         JCForLoop ForLoop(List<JCStatement> init,
3336                         JCExpression cond,
3337                         List<JCExpressionStatement> step,
3338                         JCStatement body);
3339         JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
3340         JCLabeledStatement Labelled(Name label, JCStatement body);
3341         JCSwitch Switch(JCExpression selector, List<JCCase> cases);
3342         JCSwitchExpression SwitchExpression(JCExpression selector, List<JCCase> cases);
3343         JCCase Case(CaseTree.CaseKind caseKind, List<JCCaseLabel> labels,
3344                     List<JCStatement> stats, JCTree body);

3345         JCSynchronized Synchronized(JCExpression lock, JCBlock body);
3346         JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);
3347         JCTry Try(List<JCTree> resources,
3348                   JCBlock body,
3349                   List<JCCatch> catchers,
3350                   JCBlock finalizer);
3351         JCCatch Catch(JCVariableDecl param, JCBlock body);
3352         JCConditional Conditional(JCExpression cond,
3353                                 JCExpression thenpart,
3354                                 JCExpression elsepart);
3355         JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
3356         JCExpressionStatement Exec(JCExpression expr);
3357         JCBreak Break(Name label);
3358         JCYield Yield(JCExpression value);
3359         JCContinue Continue(Name label);
3360         JCReturn Return(JCExpression expr);
3361         JCThrow Throw(JCExpression expr);
3362         JCAssert Assert(JCExpression cond, JCExpression detail);
3363         JCMethodInvocation Apply(List<JCExpression> typeargs,
3364                     JCExpression fn,

3397         JCOpens Opens(JCExpression qualId, List<JCExpression> moduleNames);
3398         JCProvides Provides(JCExpression serviceName, List<JCExpression> implNames);
3399         JCRequires Requires(boolean isTransitive, boolean isStaticPhase, JCExpression qualId);
3400         JCUses Uses(JCExpression qualId);
3401         LetExpr LetExpr(List<JCStatement> defs, JCExpression expr);
3402     }
3403 
3404     /** A generic visitor class for trees.
3405      */
3406     public abstract static class Visitor {
3407         public void visitTopLevel(JCCompilationUnit that)    { visitTree(that); }
3408         public void visitPackageDef(JCPackageDecl that)      { visitTree(that); }
3409         public void visitImport(JCImport that)               { visitTree(that); }
3410         public void visitClassDef(JCClassDecl that)          { visitTree(that); }
3411         public void visitMethodDef(JCMethodDecl that)        { visitTree(that); }
3412         public void visitVarDef(JCVariableDecl that)         { visitTree(that); }
3413         public void visitSkip(JCSkip that)                   { visitTree(that); }
3414         public void visitBlock(JCBlock that)                 { visitTree(that); }
3415         public void visitDoLoop(JCDoWhileLoop that)          { visitTree(that); }
3416         public void visitWhileLoop(JCWhileLoop that)         { visitTree(that); }

3417         public void visitForLoop(JCForLoop that)             { visitTree(that); }
3418         public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
3419         public void visitLabelled(JCLabeledStatement that)   { visitTree(that); }
3420         public void visitSwitch(JCSwitch that)               { visitTree(that); }
3421         public void visitCase(JCCase that)                   { visitTree(that); }

3422         public void visitSwitchExpression(JCSwitchExpression that)               { visitTree(that); }
3423         public void visitSynchronized(JCSynchronized that)   { visitTree(that); }
3424         public void visitTry(JCTry that)                     { visitTree(that); }
3425         public void visitCatch(JCCatch that)                 { visitTree(that); }
3426         public void visitConditional(JCConditional that)     { visitTree(that); }
3427         public void visitIf(JCIf that)                       { visitTree(that); }
3428         public void visitExec(JCExpressionStatement that)    { visitTree(that); }
3429         public void visitBreak(JCBreak that)                 { visitTree(that); }
3430         public void visitYield(JCYield that)                 { visitTree(that); }
3431         public void visitContinue(JCContinue that)           { visitTree(that); }
3432         public void visitReturn(JCReturn that)               { visitTree(that); }
3433         public void visitThrow(JCThrow that)                 { visitTree(that); }
3434         public void visitAssert(JCAssert that)               { visitTree(that); }
3435         public void visitApply(JCMethodInvocation that)      { visitTree(that); }
3436         public void visitNewClass(JCNewClass that)           { visitTree(that); }
3437         public void visitNewArray(JCNewArray that)           { visitTree(that); }
3438         public void visitLambda(JCLambda that)               { visitTree(that); }
3439         public void visitParens(JCParens that)               { visitTree(that); }
3440         public void visitAssign(JCAssign that)               { visitTree(that); }
3441         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 

 239 
 240         /** Type test expressions, of type TypeTest.
 241          */
 242         TYPETEST,
 243 
 244         /** Patterns.
 245          */
 246         BINDINGPATTERN,
 247         DEFAULTCASELABEL,
 248         GUARDPATTERN,
 249         PARENTHESIZEDPATTERN,
 250 
 251         /** Indexed array expressions, of type Indexed.
 252          */
 253         INDEXED,
 254 
 255         /** Selections, of type Select.
 256          */
 257         SELECT,
 258 
 259         /** Default values, of type DefaultValueTree.
 260          */
 261         DEFAULT_VALUE,
 262 
 263         /** Member references, of type Reference.
 264          */
 265         REFERENCE,
 266 
 267         /** Simple identifiers, of type Ident.
 268          */
 269         IDENT,
 270 
 271         /** Literals, of type Literal.
 272          */
 273         LITERAL,
 274 
 275         /** Basic type identifiers, of type TypeIdent.
 276          */
 277         TYPEIDENT,
 278 
 279         /** Array types, of type TypeArray.
 280          */
 281         TYPEARRAY,
 282 

 712 
 713     public abstract static class JCCaseLabel extends JCTree implements CaseLabelTree {
 714         public abstract boolean isExpression();
 715         public boolean isNullPattern() {
 716             return isExpression() && TreeInfo.isNull((JCExpression) this);
 717         }
 718         public abstract boolean isPattern();
 719     }
 720 
 721     public abstract static class JCExpression extends JCCaseLabel implements ExpressionTree {
 722         @Override
 723         public JCExpression setType(Type type) {
 724             super.setType(type);
 725             return this;
 726         }
 727         @Override
 728         public JCExpression setPos(int pos) {
 729             super.setPos(pos);
 730             return this;
 731         }

 732         public boolean isPoly() { return false; }
 733         public boolean isStandalone() { return true; }
 734 
 735         @Override
 736         public boolean isExpression() {
 737             return true;
 738         }
 739 
 740         @Override
 741         public boolean isPattern() {
 742             return false;
 743         }
 744     }
 745 
 746     /**
 747      * Common supertype for all poly expression trees (lambda, method references,
 748      * conditionals, method and constructor calls)
 749      */
 750     public abstract static class JCPolyExpression extends JCExpression {
 751 

 880         /** method modifiers */
 881         public JCModifiers mods;
 882         /** method name */
 883         public Name name;
 884         /** type of method return value */
 885         public JCExpression restype;
 886         /** type parameters */
 887         public List<JCTypeParameter> typarams;
 888         /** receiver parameter */
 889         public JCVariableDecl recvparam;
 890         /** value parameters */
 891         public List<JCVariableDecl> params;
 892         /** exceptions thrown by this method */
 893         public List<JCExpression> thrown;
 894         /** statements in the method */
 895         public JCBlock body;
 896         /** default value, for annotation types */
 897         public JCExpression defaultValue;
 898         /** method symbol */
 899         public MethodSymbol sym;
 900         /** nascent value that evolves into the return value for a value factory */
 901         public VarSymbol factoryProduct;
 902 
 903         /** does this method completes normally */
 904         public boolean completesNormally;
 905 
 906         protected JCMethodDecl(JCModifiers mods,
 907                             Name name,
 908                             JCExpression restype,
 909                             List<JCTypeParameter> typarams,
 910                             JCVariableDecl recvparam,
 911                             List<JCVariableDecl> params,
 912                             List<JCExpression> thrown,
 913                             JCBlock body,
 914                             JCExpression defaultValue,
 915                             MethodSymbol sym)
 916         {
 917             this.mods = mods;
 918             this.name = name;
 919             this.restype = restype;
 920             this.typarams = typarams;
 921             this.params = params;
 922             this.recvparam = recvparam;

1162         @Override
1163         public void accept(Visitor v) { v.visitWhileLoop(this); }
1164 
1165         @DefinedBy(Api.COMPILER_TREE)
1166         public Kind getKind() { return Kind.WHILE_LOOP; }
1167         @DefinedBy(Api.COMPILER_TREE)
1168         public JCExpression getCondition() { return cond; }
1169         @DefinedBy(Api.COMPILER_TREE)
1170         public JCStatement getStatement() { return body; }
1171         @Override @DefinedBy(Api.COMPILER_TREE)
1172         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1173             return v.visitWhileLoop(this, d);
1174         }
1175 
1176         @Override
1177         public Tag getTag() {
1178             return WHILELOOP;
1179         }
1180     }
1181 
1182     /**
1183      * A withfield expression
1184      */
1185     public static class JCWithField extends JCExpression implements WithFieldTree {
1186         public JCExpression field;
1187         public JCExpression value;
1188         protected JCWithField(JCExpression field, JCExpression value) {
1189             this.field = field;
1190             this.value = value;
1191         }
1192         @Override
1193         public void accept(Visitor v) { v.visitWithField(this); }
1194 
1195         @DefinedBy(Api.COMPILER_TREE)
1196         public Kind getKind() { return Kind.WITH_FIELD; }
1197         @DefinedBy(Api.COMPILER_TREE)
1198         public JCExpression getField() { return field; }
1199         @DefinedBy(Api.COMPILER_TREE)
1200         public JCExpression getValue() { return value; }
1201         @Override @DefinedBy(Api.COMPILER_TREE)
1202         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1203             return v.visitWithField(this, d);
1204         }
1205 
1206         @Override
1207         public Tag getTag() {
1208             return WITHFIELD;
1209         }
1210     }
1211 
1212     /**
1213      * A for loop.
1214      */
1215     public static class JCForLoop extends JCStatement implements ForLoopTree {
1216         public List<JCStatement> init;
1217         public JCExpression cond;
1218         public List<JCExpressionStatement> step;
1219         public JCStatement body;
1220         protected JCForLoop(List<JCStatement> init,
1221                           JCExpression cond,
1222                           List<JCExpressionStatement> update,
1223                           JCStatement body)
1224         {
1225             this.init = init;
1226             this.cond = cond;
1227             this.step = update;
1228             this.body = body;
1229         }
1230         @Override
1231         public void accept(Visitor v) { v.visitForLoop(this); }

1386         @Override @DefinedBy(Api.COMPILER_TREE)
1387         public List<JCStatement> getStatements() {
1388             return caseKind == CaseKind.STATEMENT ? stats : null;
1389         }
1390         @Override @DefinedBy(Api.COMPILER_TREE)
1391         public JCTree getBody() { return body; }
1392         @Override @DefinedBy(Api.COMPILER_TREE)
1393         public CaseKind getCaseKind() {
1394             return caseKind;
1395         }
1396         @Override @DefinedBy(Api.COMPILER_TREE)
1397         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1398             return v.visitCase(this, d);
1399         }
1400         @Override
1401         public Tag getTag() {
1402             return CASE;
1403         }
1404     }
1405 
1406     /**
1407      * A "Identifier<TA1, TA2>.default" construction.
1408      */
1409     public static class JCDefaultValue extends JCPolyExpression implements DefaultValueTree {
1410         public JCExpression clazz;
1411 
1412         protected JCDefaultValue(JCExpression clazz) {
1413             this.clazz = clazz;
1414         }
1415         @Override
1416         public void accept(Visitor v) { v.visitDefaultValue(this); }
1417 
1418         @DefinedBy(Api.COMPILER_TREE)
1419         public Kind getKind() { return Kind.DEFAULT_VALUE; }
1420         @Override @DefinedBy(Api.COMPILER_TREE)
1421         public JCExpression getType() { return clazz; }
1422         @Override @DefinedBy(Api.COMPILER_TREE)
1423         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1424             return v.visitDefaultValue(this, d);
1425         }
1426         @Override
1427         public Tag getTag() {
1428             return DEFAULT_VALUE;
1429         }
1430     }
1431 
1432     /**
1433      * A "switch ( ) { }" construction.
1434      */
1435     public static class JCSwitchExpression extends JCPolyExpression implements SwitchExpressionTree {
1436         public JCExpression selector;
1437         public List<JCCase> cases;
1438         /** Position of closing brace, optional. */
1439         public int endpos = Position.NOPOS;
1440         public boolean hasTotalPattern;
1441         public boolean isExhaustive;
1442         public boolean patternSwitch;
1443         protected JCSwitchExpression(JCExpression selector, List<JCCase> cases) {
1444             this.selector = selector;
1445             this.cases = cases;
1446         }
1447         @Override
1448         public void accept(Visitor v) { v.visitSwitchExpression(this); }
1449 
1450         @DefinedBy(Api.COMPILER_TREE)
1451         public Kind getKind() { return Kind.SWITCH_EXPRESSION; }

3391                             JCBlock body,
3392                             JCExpression defaultValue);
3393         JCVariableDecl VarDef(JCModifiers mods,
3394                       Name name,
3395                       JCExpression vartype,
3396                       JCExpression init);
3397         JCSkip Skip();
3398         JCBlock Block(long flags, List<JCStatement> stats);
3399         JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);
3400         JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);
3401         JCForLoop ForLoop(List<JCStatement> init,
3402                         JCExpression cond,
3403                         List<JCExpressionStatement> step,
3404                         JCStatement body);
3405         JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
3406         JCLabeledStatement Labelled(Name label, JCStatement body);
3407         JCSwitch Switch(JCExpression selector, List<JCCase> cases);
3408         JCSwitchExpression SwitchExpression(JCExpression selector, List<JCCase> cases);
3409         JCCase Case(CaseTree.CaseKind caseKind, List<JCCaseLabel> labels,
3410                     List<JCStatement> stats, JCTree body);
3411         JCDefaultValue DefaultValue(JCExpression type);
3412         JCSynchronized Synchronized(JCExpression lock, JCBlock body);
3413         JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);
3414         JCTry Try(List<JCTree> resources,
3415                   JCBlock body,
3416                   List<JCCatch> catchers,
3417                   JCBlock finalizer);
3418         JCCatch Catch(JCVariableDecl param, JCBlock body);
3419         JCConditional Conditional(JCExpression cond,
3420                                 JCExpression thenpart,
3421                                 JCExpression elsepart);
3422         JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
3423         JCExpressionStatement Exec(JCExpression expr);
3424         JCBreak Break(Name label);
3425         JCYield Yield(JCExpression value);
3426         JCContinue Continue(Name label);
3427         JCReturn Return(JCExpression expr);
3428         JCThrow Throw(JCExpression expr);
3429         JCAssert Assert(JCExpression cond, JCExpression detail);
3430         JCMethodInvocation Apply(List<JCExpression> typeargs,
3431                     JCExpression fn,

3464         JCOpens Opens(JCExpression qualId, List<JCExpression> moduleNames);
3465         JCProvides Provides(JCExpression serviceName, List<JCExpression> implNames);
3466         JCRequires Requires(boolean isTransitive, boolean isStaticPhase, JCExpression qualId);
3467         JCUses Uses(JCExpression qualId);
3468         LetExpr LetExpr(List<JCStatement> defs, JCExpression expr);
3469     }
3470 
3471     /** A generic visitor class for trees.
3472      */
3473     public abstract static class Visitor {
3474         public void visitTopLevel(JCCompilationUnit that)    { visitTree(that); }
3475         public void visitPackageDef(JCPackageDecl that)      { visitTree(that); }
3476         public void visitImport(JCImport that)               { visitTree(that); }
3477         public void visitClassDef(JCClassDecl that)          { visitTree(that); }
3478         public void visitMethodDef(JCMethodDecl that)        { visitTree(that); }
3479         public void visitVarDef(JCVariableDecl that)         { visitTree(that); }
3480         public void visitSkip(JCSkip that)                   { visitTree(that); }
3481         public void visitBlock(JCBlock that)                 { visitTree(that); }
3482         public void visitDoLoop(JCDoWhileLoop that)          { visitTree(that); }
3483         public void visitWhileLoop(JCWhileLoop that)         { visitTree(that); }
3484         public void visitWithField(JCWithField that)         { visitTree(that); }
3485         public void visitForLoop(JCForLoop that)             { visitTree(that); }
3486         public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
3487         public void visitLabelled(JCLabeledStatement that)   { visitTree(that); }
3488         public void visitSwitch(JCSwitch that)               { visitTree(that); }
3489         public void visitCase(JCCase that)                   { visitTree(that); }
3490         public void visitDefaultValue(JCDefaultValue that) { visitTree(that); }
3491         public void visitSwitchExpression(JCSwitchExpression that)               { visitTree(that); }
3492         public void visitSynchronized(JCSynchronized that)   { visitTree(that); }
3493         public void visitTry(JCTry that)                     { visitTree(that); }
3494         public void visitCatch(JCCatch that)                 { visitTree(that); }
3495         public void visitConditional(JCConditional that)     { visitTree(that); }
3496         public void visitIf(JCIf that)                       { visitTree(that); }
3497         public void visitExec(JCExpressionStatement that)    { visitTree(that); }
3498         public void visitBreak(JCBreak that)                 { visitTree(that); }
3499         public void visitYield(JCYield that)                 { visitTree(that); }
3500         public void visitContinue(JCContinue that)           { visitTree(that); }
3501         public void visitReturn(JCReturn that)               { visitTree(that); }
3502         public void visitThrow(JCThrow that)                 { visitTree(that); }
3503         public void visitAssert(JCAssert that)               { visitTree(that); }
3504         public void visitApply(JCMethodInvocation that)      { visitTree(that); }
3505         public void visitNewClass(JCNewClass that)           { visitTree(that); }
3506         public void visitNewArray(JCNewArray that)           { visitTree(that); }
3507         public void visitLambda(JCLambda that)               { visitTree(that); }
3508         public void visitParens(JCParens that)               { visitTree(that); }
3509         public void visitAssign(JCAssign that)               { visitTree(that); }
3510         public void visitAssignop(JCAssignOp that)           { visitTree(that); }
< prev index next >