Complete AST nodes for switch statement.

dart/frog/leg/tree/nodes.dart

Index: dart/frog/leg/tree/nodes.dart
diff --git a/dart/frog/leg/tree/nodes.dart b/dart/frog/leg/tree/nodes.dart
index bc1ec4382f697bd183c7a5240c4914faa5138174..9bf503670296063715847efb10ab26b6d3c12255 100644
--- a/dart/frog/leg/tree/nodes.dart
+++ b/dart/frog/leg/tree/nodes.dart
@@ -9,6 +9,7 @@ interface Visitor<R> {
   R visitClassNode(ClassNode node);
   R visitConditional(Conditional node);
   R visitContinueStatement(ContinueStatement node);
+  R visitDefaultCase(DefaultCase node);
   R visitDoWhile(DoWhile node);
   R visitEmptyStatement(EmptyStatement node);
   R visitExpressionStatement(ExpressionStatement node);
@@ -40,6 +41,7 @@ interface Visitor<R> {
   R visitSendSet(SendSet node);
   R visitStringInterpolation(StringInterpolation node);
   R visitStringInterpolationPart(StringInterpolationPart node);
+  R visitSwitchCase(SwitchCase node);
   R visitSwitchStatement(SwitchStatement node);
   R visitThrow(Throw node);
   R visitTryStatement(TryStatement node);
@@ -102,6 +104,7 @@ class Node implements Hashable {
   ClassNode asClassNode() => null;
   Conditional asConditional() => null;
   ContinueStatement asContinueStatement() => null;
+  DefaultCase asDefaultCase() => null;
   DoWhile asDoWhile() => null;
   EmptyStatement asEmptyStatement() => null;
   Expression asExpression() => null;
@@ -133,6 +136,7 @@ class Node implements Hashable {
   Statement asStatement() => null;
   StringInterpolation asStringInterpolation() => null;
   StringInterpolationPart asStringInterpolationPart() => null;
+  SwitchCase asSwitchCase() => null;
   SwitchStatement asSwitchStatement() => null;
   Throw asThrow() => null;
   TryStatement asTryStatement() => null;
@@ -1374,13 +1378,12 @@ class NamedArgument extends Expression {
 
 class SwitchStatement extends Statement {
   final ParenthesizedExpression parenthesizedExpression;
+  final NodeList cases;
 
   final Token switchKeyword;
-  final Token endToken;
-  // TODO(ahe): More to come...
 
-  SwitchStatement(this.parenthesizedExpression,
-                  this.switchKeyword, this.endToken);
+  SwitchStatement(this.parenthesizedExpression, this.cases,
+                  this.switchKeyword);
 
   SwitchStatement asSwitchStatement() => this;
 
@@ -1390,12 +1393,64 @@ class SwitchStatement extends Statement {
 
   visitChildren(Visitor visitor) {
     parenthesizedExpression.accept(visitor);
-    // TODO(ahe): Add more stuff here.
+    cases.accept(visitor);
   }
 
   Token getBeginToken() => switchKeyword;
 
-  Token getEndToken() => endToken;
+  Token getEndToken() => cases.getEndToken();
+}
+
+class SwitchCase extends Node {
+  final Identifier label;
+  final Expression expression;

[Lasse Reichstein Nielsen, 2012/03/05 19:54:04]

Only one expression per case?
How is 
 foo: case 1: case 2: stmts;
modelled?

[ahe, 2012/03/05 20:07:23]

new SwitchCase('foo', 1, []);
new SwitchCase(null, 2, stmts);

I'm currently working on generating code and I may change this.

+  final NodeList statements;
+
+  final Token caseKeyword;
+
+  SwitchCase(this.label, this.expression, this.statements, this.caseKeyword);
+
+  SwitchCase asSwitchCase() => this;
+
+  accept(Visitor visitor) => visitor.visitSwitchCase(this);
+
+  visitChildren(Visitor visitor) {
+    if (label !== null) label.accept(visitor);
+    expression.accept(visitor);
+    statements.accept(visitor);
+  }
+
+  Token getBeginToken() {
+    if (label !== null) return label.getBeginToken();
+    return caseKeyword;
+  }
+
+  Token getEndToken() => statements.getEndToken();
+}
+
+class DefaultCase extends Node {
+  final Identifier label;
+  final NodeList statements;
+
+  final Token defaultKeyword;
+
+  DefaultCase(this.label, this.statements, this.defaultKeyword);
+
+  DefaultCase asDefaultCase() => this;
+
+  accept(Visitor visitor) => visitor.visitDefaultCase(this);
+
+  visitChildren(Visitor visitor) {
+    if (label !== null) label.accept(visitor);
+    statements.accept(visitor);
+  }
+
+  Token getBeginToken() {
+    if (label === null) return label.getBeginToken();
+    return defaultKeyword;
+  }
+
+  Token getEndToken() => statements.getEndToken();
 }
 
 class GotoStatement extends Statement {