Add a "Label" Node around an Identifier that is being used as a label.

lib/compiler/implementation/tree/nodes.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 interface Visitor<R> {
   R visitBlock(Block node);
   R visitBreakStatement(BreakStatement node);
   R visitCascade(Cascade node);
   R visitCascadeReceiver(CascadeReceiver node);
   R visitCatchBlock(CatchBlock node);
   R visitClassNode(ClassNode node);
   R visitConditional(Conditional node);
   R visitContinueStatement(ContinueStatement node);
   R visitDoWhile(DoWhile node);
   R visitEmptyStatement(EmptyStatement node);
   R visitExpressionStatement(ExpressionStatement node);
   R visitFor(For node);
   R visitForIn(ForIn node);
   R visitFunctionDeclaration(FunctionDeclaration node);
   R visitFunctionExpression(FunctionExpression node);
   R visitIdentifier(Identifier node);
   R visitIf(If node);
+  R visitLabel(Label node);
   R visitLabeledStatement(LabeledStatement node);
   R visitLiteralBool(LiteralBool node);
   R visitLiteralDouble(LiteralDouble node);
   R visitLiteralInt(LiteralInt node);
   R visitLiteralList(LiteralList node);
   R visitLiteralMap(LiteralMap node);
   R visitLiteralMapEntry(LiteralMapEntry node);
   R visitLiteralNull(LiteralNull node);
   R visitLiteralString(LiteralString node);
   R visitStringJuxtaposition(StringJuxtaposition node);
@@ skipping 86 matching lines @@
   DoWhile asDoWhile() => null;
   EmptyStatement asEmptyStatement() => null;
   Expression asExpression() => null;
   ExpressionStatement asExpressionStatement() => null;
   For asFor() => null;
   ForIn asForIn() => null;
   FunctionDeclaration asFunctionDeclaration() => null;
   FunctionExpression asFunctionExpression() => null;
   Identifier asIdentifier() => null;
   If asIf() => null;
+  Label asLabel() => null;
   LabeledStatement asLabeledStatement() => null;
   LiteralBool asLiteralBool() => null;
   LiteralDouble asLiteralDouble() => null;
   LiteralInt asLiteralInt() => null;
   LiteralList asLiteralList() => null;
   LiteralMap asLiteralMap() => null;
   LiteralMapEntry asLiteralMapEntry() => null;
   LiteralNull asLiteralNull() => null;
   LiteralString asLiteralString() => null;
   Modifiers asModifiers() => null;
@@ skipping 1180 matching lines @@
   Token getEndToken() => cases.getEndToken();
 }
 
 class SwitchCase extends Node {
   // Represents the grammar:
   //   label? ('case' expression ':')* ('default' ':')? statement*
   // Each expression is collected in [expressions].
   // The 'case' keywords can be obtained using [caseKeywords()].
   // Any actual switch case must have at least one 'case' or 'default'
   // clause.
-  final Identifier label;
+  final Label label;
   final NodeList expressions;
   final Token defaultKeyword;
   final NodeList statements;
 
   final Token startToken;
 
   SwitchCase(this.label, this.expressions, this.defaultKeyword,
              this.statements, this.startToken);
 
   SwitchCase asSwitchCase() => this;
@@ skipping 102 matching lines @@
     declaredIdentifier.accept(visitor);
     expression.accept(visitor);
     body.accept(visitor);
   }
 
   Token getBeginToken() => forToken;
 
   Token getEndToken() => body.getEndToken();
 }
 
+class Label extends Node {
+  final Identifier identifier;
+  final Token colonToken;
+
+  Label(this.identifier, this.colonToken);
+
+  String slowToString() => identifier.source.slowToString();
+
+  Label asLabel() => this;
+
+  accept(Visitor visitor) => visitor.visitLabel(this);
+
+  void visitChildren(Visitor visitor) {
+    identifier.accept(visitor);
+  }
+
+  Token getBeginToken() => identifier.token;
+  Token getEndToken() => colonToken;
+}
+
 class LabeledStatement extends Statement {
-  final Identifier label;
-  final Token colonToken;
+  final Label label;
   final Statement statement;
 
-  LabeledStatement(this.label, this.colonToken, this.statement);
+  LabeledStatement(this.label, this.statement);
 
   LabeledStatement asLabeledStatement() => this;
 
   accept(Visitor visitor) => visitor.visitLabeledStatement(this);
 
   visitChildren(Visitor visitor) {
     label.accept(visitor);
     statement.accept(visitor);
   }
 
@@ skipping 213 matching lines @@
  * argument).
  *
  * TODO(ahe): This method is controversial, the team needs to discuss
  * if top-level methods are acceptable and what naming conventions to
  * use.
  */
 initializerDo(Node node, f(Node node)) {
   SendSet send = node.asSendSet();
   if (send !== null) return f(send.arguments.head);
 }