< prev index next >
src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java
Print this page
rev 51258 : imported patch switch.diff
@@ -45,14 +45,16 @@
import static com.sun.tools.javac.tree.JCTree.Tag.*;
import javax.tools.JavaFileManager.Location;
+import com.sun.source.tree.CaseTree.CaseKind;
import com.sun.source.tree.ModuleTree.ModuleKind;
import com.sun.tools.javac.code.Directive.ExportsDirective;
import com.sun.tools.javac.code.Directive.OpensDirective;
import com.sun.tools.javac.code.Type.ModuleType;
+import com.sun.tools.javac.tree.JCTree.JCPolyExpression.PolyKind;
/**
* Root class for abstract syntax tree nodes. It provides definitions
* for specific tree nodes as subclasses nested inside.
*
@@ -147,14 +149,18 @@
/** Switch statements, of type Switch.
*/
SWITCH,
- /** Case parts in switch statements, of type Case.
+ /** Case parts in switch statements/expressions, of type Case.
*/
CASE,
+ /** Switch expression statements, of type Switch.
+ */
+ SWITCH_EXPRESSION,
+
/** Synchronized statements, of type Synchonized.
*/
SYNCHRONIZED,
/** Try statements, of type Try.
@@ -1236,25 +1242,54 @@
/**
* A "case :" of a switch.
*/
public static class JCCase extends JCStatement implements CaseTree {
- public JCExpression pat;
+ //as CaseKind is deprecated for removal (as it is part of a preview feature),
+ //using indirection through these fields to avoid unnecessary @SuppressWarnings:
+ @SuppressWarnings("removal")
+ public static final CaseKind STATEMENT = CaseKind.STATEMENT;
+ @SuppressWarnings("removal")
+ public static final CaseKind RULE = CaseKind.RULE;
+ @SuppressWarnings("removal")
+ public final CaseKind caseKind;
+ public List<JCExpression> pats;
public List<JCStatement> stats;
- protected JCCase(JCExpression pat, List<JCStatement> stats) {
- this.pat = pat;
+ public JCTree body;
+ public boolean completesNormally;
+ protected JCCase(@SuppressWarnings("removal") CaseKind caseKind, List<JCExpression> pats,
+ List<JCStatement> stats, JCTree body) {
+ Assert.checkNonNull(pats);
+ Assert.check(pats.isEmpty() || pats.head != null);
+ this.caseKind = caseKind;
+ this.pats = pats;
this.stats = stats;
+ this.body = body;
}
@Override
public void accept(Visitor v) { v.visitCase(this); }
- @DefinedBy(Api.COMPILER_TREE)
+ @Override @DefinedBy(Api.COMPILER_TREE)
public Kind getKind() { return Kind.CASE; }
- @DefinedBy(Api.COMPILER_TREE)
- public JCExpression getExpression() { return pat; }
- @DefinedBy(Api.COMPILER_TREE)
- public List<JCStatement> getStatements() { return stats; }
+ @Override @DefinedBy(Api.COMPILER_TREE)
+ public JCExpression getExpression() { return pats.head; }
+ @Override @DefinedBy(Api.COMPILER_TREE)
+ @SuppressWarnings("removal")
+ public List<JCExpression> getExpressions() { return pats; }
+ @Override @DefinedBy(Api.COMPILER_TREE)
+ @SuppressWarnings("removal")
+ public List<JCStatement> getStatements() {
+ return caseKind == CaseKind.STATEMENT ? stats : null;
+ }
+ @Override @DefinedBy(Api.COMPILER_TREE)
+ @SuppressWarnings("removal")
+ public JCTree getBody() { return body; }
+ @Override @DefinedBy(Api.COMPILER_TREE)
+ @SuppressWarnings("removal")
+ public CaseKind getCaseKind() {
+ return caseKind;
+ }
@Override @DefinedBy(Api.COMPILER_TREE)
public <R,D> R accept(TreeVisitor<R,D> v, D d) {
return v.visitCase(this, d);
}
@Override
@@ -1262,10 +1297,40 @@
return CASE;
}
}
/**
+ * A "switch ( ) { }" construction.
+ */
+ @SuppressWarnings("removal")
+ public static class JCSwitchExpression extends JCPolyExpression implements SwitchExpressionTree {
+ public JCExpression selector;
+ public List<JCCase> cases;
+ protected JCSwitchExpression(JCExpression selector, List<JCCase> cases) {
+ this.selector = selector;
+ this.cases = cases;
+ }
+ @Override
+ public void accept(Visitor v) { v.visitSwitchExpression(this); }
+
+ @DefinedBy(Api.COMPILER_TREE)
+ public Kind getKind() { return Kind.SWITCH_EXPRESSION; }
+ @DefinedBy(Api.COMPILER_TREE)
+ public JCExpression getExpression() { return selector; }
+ @DefinedBy(Api.COMPILER_TREE)
+ public List<JCCase> getCases() { return cases; }
+ @Override @DefinedBy(Api.COMPILER_TREE)
+ public <R,D> R accept(TreeVisitor<R,D> v, D d) {
+ return v.visitSwitchExpression(this, d);
+ }
+ @Override
+ public Tag getTag() {
+ return SWITCH_EXPRESSION;
+ }
+ }
+
+ /**
* A synchronized block.
*/
public static class JCSynchronized extends JCStatement implements SynchronizedTree {
public JCExpression lock;
public JCBlock body;
@@ -1482,23 +1547,31 @@
/**
* A break from a loop or switch.
*/
public static class JCBreak extends JCStatement implements BreakTree {
- public Name label;
+ public JCExpression value;
public JCTree target;
- protected JCBreak(Name label, JCTree target) {
- this.label = label;
+ protected JCBreak(JCExpression value, JCTree target) {
+ this.value = value;
this.target = target;
}
@Override
public void accept(Visitor v) { v.visitBreak(this); }
+ public boolean isValueBreak() {
+ return target != null && target.hasTag(SWITCH_EXPRESSION);
+ }
@DefinedBy(Api.COMPILER_TREE)
public Kind getKind() { return Kind.BREAK; }
@DefinedBy(Api.COMPILER_TREE)
- public Name getLabel() { return label; }
+ public Name getLabel() {
+ return value != null && value.getKind() == Kind.IDENTIFIER ? ((JCIdent) value).getName() : null;
+ }
+ @DefinedBy(Api.COMPILER_TREE)
+ @SuppressWarnings("removal")
+ public JCExpression getValue() { return value; }
@Override @DefinedBy(Api.COMPILER_TREE)
public <R,D> R accept(TreeVisitor<R,D> v, D d) {
return v.visitBreak(this, d);
}
@Override
@@ -2932,13 +3005,13 @@
}
}
/** (let int x = 3; in x+2) */
public static class LetExpr extends JCExpression {
- public List<JCVariableDecl> defs;
+ public List<JCStatement> defs;
public JCExpression expr;
- protected LetExpr(List<JCVariableDecl> defs, JCExpression expr) {
+ protected LetExpr(List<JCStatement> defs, JCExpression expr) {
this.defs = defs;
this.expr = expr;
}
@Override
public void accept(Visitor v) { v.visitLetExpr(this); }
@@ -2992,11 +3065,13 @@
List<JCExpressionStatement> step,
JCStatement body);
JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
JCLabeledStatement Labelled(Name label, JCStatement body);
JCSwitch Switch(JCExpression selector, List<JCCase> cases);
- JCCase Case(JCExpression pat, List<JCStatement> stats);
+ JCSwitchExpression SwitchExpression(JCExpression selector, List<JCCase> cases);
+ JCCase Case(@SuppressWarnings("removal") CaseKind caseKind, List<JCExpression> pat,
+ List<JCStatement> stats, JCTree body);
JCSynchronized Synchronized(JCExpression lock, JCBlock body);
JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);
JCTry Try(List<JCTree> resources,
JCBlock body,
List<JCCatch> catchers,
@@ -3005,11 +3080,11 @@
JCConditional Conditional(JCExpression cond,
JCExpression thenpart,
JCExpression elsepart);
JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
JCExpressionStatement Exec(JCExpression expr);
- JCBreak Break(Name label);
+ JCBreak Break(JCExpression value);
JCContinue Continue(Name label);
JCReturn Return(JCExpression expr);
JCThrow Throw(JCExpression expr);
JCAssert Assert(JCExpression cond, JCExpression detail);
JCMethodInvocation Apply(List<JCExpression> typeargs,
@@ -3047,11 +3122,11 @@
JCExports Exports(JCExpression qualId, List<JCExpression> moduleNames);
JCOpens Opens(JCExpression qualId, List<JCExpression> moduleNames);
JCProvides Provides(JCExpression serviceName, List<JCExpression> implNames);
JCRequires Requires(boolean isTransitive, boolean isStaticPhase, JCExpression qualId);
JCUses Uses(JCExpression qualId);
- LetExpr LetExpr(List<JCVariableDecl> defs, JCExpression expr);
+ LetExpr LetExpr(List<JCStatement> defs, JCExpression expr);
}
/** A generic visitor class for trees.
*/
public static abstract class Visitor {
@@ -3068,10 +3143,11 @@
public void visitForLoop(JCForLoop that) { visitTree(that); }
public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
public void visitLabelled(JCLabeledStatement that) { visitTree(that); }
public void visitSwitch(JCSwitch that) { visitTree(that); }
public void visitCase(JCCase that) { visitTree(that); }
+ public void visitSwitchExpression(JCSwitchExpression that) { visitTree(that); }
public void visitSynchronized(JCSynchronized that) { visitTree(that); }
public void visitTry(JCTry that) { visitTree(that); }
public void visitCatch(JCCatch that) { visitTree(that); }
public void visitConditional(JCConditional that) { visitTree(that); }
public void visitIf(JCIf that) { visitTree(that); }
< prev index next >