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

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 967 matching lines @@
 
   static bool isListSupertype(Element element, Compiler compiler) {
     LibraryElement coreLibrary = compiler.coreLibrary;
     return (element == coreLibrary.find(const SourceString('Collection')))
         || (element == coreLibrary.find(const SourceString('Iterable')));
   }
 }
 
 
 class LabelElement extends Element {
-  final Identifier label;
+  final Label label;

[ahe, 2012/05/10 11:52:30]

Could you add a comment explaining why you need the AST node here. Normally, we
don't like requiring AST nodes for elements, but in this case it makes sense.

[Lasse Reichstein Nielsen, 2012/05/10 12:14:20]

Done.

   final String labelName;
   final TargetElement target;
   bool isBreakTarget = false;
   bool isContinueTarget = false;
-  LabelElement(Identifier label, this.labelName, this.target,
+  LabelElement(Label label, this.labelName, this.target,
                Element enclosingElement)
       : this.label = label,
-        super(label.source, ElementKind.LABEL, enclosingElement);
+        super(label.identifier.source, ElementKind.LABEL, enclosingElement);
 
   void setBreakTarget() {
     isBreakTarget = true;
     target.isBreakTarget = true;
   }
   void setContinueTarget() {
     isContinueTarget = true;
     target.isContinueTarget = true;
   }
 
   bool get isTarget() => isBreakTarget || isContinueTarget;
   Node parseNode(DiagnosticListener l) => label;
 
-  Token position() => label.token;
+  Token position() => label.getBeginToken();
   String toString() => "${labelName}:";
 }
 
 // Represents a reference to a statement, either a label or the
 // default target of a break or continue.
 class TargetElement extends Element {
   // TODO(lrn): StatementElement is not just referencing statements anymore.
   final Node statement;
   final int nestingLevel;
   Link<LabelElement> labels = const EmptyLink<LabelElement>();
   bool isBreakTarget = false;
   bool isContinueTarget = false;
 
   TargetElement(this.statement, this.nestingLevel, Element enclosingElement)
       : super(const SourceString(""), ElementKind.STATEMENT, enclosingElement);
   bool get isTarget() => isBreakTarget || isContinueTarget;
 
-  LabelElement addLabel(Identifier label, String labelName) {
+  LabelElement addLabel(Label label, String labelName) {
     LabelElement result = new LabelElement(label, labelName, this,
                                            enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 
   bool get isSwitch() => statement is SwitchStatement;
 
   Token position() => statement.getBeginToken();
   String toString() => statement.toString();
 }
 
 class TypeVariableElement extends Element {
   final Node node;
   Type bound;
   Type type;
   TypeVariableElement(name, Element enclosing, this.node, this.type,
                       [this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
   Type computeType(compiler) => type;
   Node parseNode(compiler) => node;
   toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }