Switch-implementation.

frog/leg/resolver.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 TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 460 matching lines @@
 
 interface LabelScope {
   LabelScope get outer();
   LabelElement lookup(String label);
 }
 
 class LabeledStatementLabelScope implements LabelScope {
   final LabelScope outer;
   final LabelElement label;
   LabeledStatementLabelScope(this.outer, this.label);
-  LabelElement lookup(String labelName) {
+  LabelElement lookupBreak(String labelName) {
     if (this.label.labelName == labelName) return label;
-    return outer.lookup(labelName);
+    return outer.lookupBreak(labelName);
+  }
+  LabelElement lookupContinue(String labelName) {
+    if (this.label.labelName == labelName) return label;
+    return outer.lookupContinue(labelName);
   }
 }
 
+
+class SwitchLabelScope implements LabelScope {
+  final LabelScope outer;
+  final Map<String, LabelElement> caseLabels;
+  SwitchLabelScope(this.outer, this.caseLabels);
+  LabelElement lookupBreak(String labelName) {
+    return outer.lookupBreak(labelName);
+  }
+  LabelElement lookupContinue(String labelName) {
+    LabelElement result = caseLabels[labelName];
+    if (result !== null) return result;
+    return outer.lookupContinue(labelName);
+  }
+}
+
+
 class EmptyLabelScope implements LabelScope {
   const EmptyLabelScope();
-  LabelElement lookup(String label) => null;
+  LabelElement lookupBreak(String label) => null;
+  LabelElement lookupContinue(String label) => null;
   LabelScope get outer() {
     throw 'internal error: empty label scope has no outer';
   }
 }
 
 class StatementScope {
   LabelScope labels;
   Link<StatementElement> breakTargetStack;

[floitsch, 2012/03/08 16:35:14]

These (the break and the continueTargetStack) are only for breaks and continues
without ids. correct?
if yes, please add a comment.
If not, please please add a comment.

[Lasse Reichstein Nielsen, 2012/03/08 18:35:40]

Yes. Will add comment.

   Link<StatementElement> continueTargetStack;
 
   StatementScope()
       : labels = const EmptyLabelScope(),
         breakTargetStack = const EmptyLink<StatementElement>(),
         continueTargetStack = const EmptyLink<StatementElement>();
 
-  LabelElement lookupLabel(String label) => labels.lookup(label);
+  LabelElement lookupBreakLabel(String label) =>
+      labels.lookupBreak(label);
+
+  LabelElement lookupContinueLabel(String label) =>
+      labels.lookupContinue(label);
+
   StatementElement currentBreakTarget() =>
     breakTargetStack.isEmpty() ? null : breakTargetStack.head;
+
   StatementElement currentContinueTarget() =>
     continueTargetStack.isEmpty() ? null : continueTargetStack.head;
 
   void enterLabelScope(LabelElement element) {
     labels = new LabeledStatementLabelScope(labels, element);
   }
+
   void exitLabelScope() {
     labels = labels.outer;
   }
+
   void enterLoop(StatementElement element) {
     breakTargetStack = breakTargetStack.prepend(element);
     continueTargetStack = continueTargetStack.prepend(element);
   }
+
   void exitLoop() {
     breakTargetStack = breakTargetStack.tail;
     continueTargetStack = continueTargetStack.tail;
   }
+
+  void enterSwitch(StatementElement breakElement,
+                   Map<String, LabelElement> continueElements) {
+    breakTargetStack = breakTargetStack.prepend(breakElement);
+    labels = new SwitchLabelScope(labels, continueElements);
+  }
+
+  void exitSwitch() {
+    breakTargetStack = breakTargetStack.tail;
+    labels = labels.outer;
+  }
 }
 
 
 class ResolverVisitor extends CommonResolverVisitor<Element> {
   final TreeElementMapping mapping;
   final Element enclosingElement;
   bool inInstanceContext;
   Scope context;
   ClassElement currentClass;
   bool typeRequired = false;
@@ skipping 507 matching lines @@
     StatementElement target;
     if (node.target === null) {
       target = statementScope.currentBreakTarget();
       if (target === null) {
         error(node, MessageKind.NO_BREAK_TARGET);
         return;
       }
       target.isBreakTarget = true;
     } else {
       String labelName = node.target.source.slowToString();
-      LabelElement label = statementScope.lookupLabel(labelName);
+      LabelElement label = statementScope.lookupBreakLabel(labelName);
       if (label === null) {
         error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
         return;
       }
       target = label.target;
       label.setBreakTarget();
       mapping[node.target] = label;
     }
     mapping[node] = target;
   }
 
   visitContinueStatement(ContinueStatement node) {
     StatementElement target;
     if (node.target === null) {
       target = statementScope.currentContinueTarget();
       if (target === null) {
         error(node, MessageKind.NO_CONTINUE_TARGET);
         return;
       }
     } else {
       String labelName = node.target.source.slowToString();
-      LabelElement label = statementScope.lookupLabel(labelName);
+      LabelElement label = statementScope.lookupContinueLabel(labelName);
       if (label === null) {
         error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
         return;
       }
       target = label.target;
       if (!target.statement.isValidContinueTarget()) {
         error(node.target, MessageKind.INVALID_CONTINUE, [labelName]);
       }
     }
     target.isContinueTarget = true;
@@ skipping 13 matching lines @@
         !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty()))
     {
       // The variable declaration is either not an identifier, not a
       // declaration, or it's declaring more than one variable.
       error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN, []);
     }
   }
 
   visitLabelledStatement(LabelledStatement node) {
     String labelName = node.label.source.slowToString();
-    LabelElement existingElement = statementScope.lookupLabel(labelName);
+    LabelElement existingElement = statementScope.lookupBreakLabel(labelName);
     if (existingElement !== null) {
       warning(node.label, MessageKind.DUPLICATE_LABEL, [labelName]);
       warning(existingElement.label, MessageKind.EXISTING_LABEL, [labelName]);
     }
     Node body = node.getBody();
     StatementElement statementElement = getOrCreateStatementElement(body);
 
     LabelElement element = statementElement.addLabel(node.label, labelName);
     statementScope.enterLabelScope(element);
     visit(node.statement);
@@ skipping 17 matching lines @@
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
-    StatementElement element = getOrCreateStatementElement(node);
-    statementScope.enterLoop(element);
+
+    StatementElement breakElement = getOrCreateStatementElement(node);
+    Map<String, LabelElement> continueLabels = <LabelElement>{};
+    for (SwitchCase switchCase in node.cases) {
+      if (switchCase.label !== null) {
+        Identifier labelIdentifier = switchCase.label;
+        String labelName = labelIdentifier.source.slowToString();
+
+        LabelElement existingElement = continueLabels[labelName];
+        if (existingElement !== null) {
+          // It's an error if the same label occurs twice in the same switch.
+          warning(labelIdentifier, MessageKind.DUPLICATE_LABEL, [labelName]);
+          error(existingElement.label, MessageKind.EXISTING_LABEL, [labelName]);
+        } else {
+          // It's only a warning if it shadows another label.
+          existingElement = statementScope.lookupContinue(labelName);
+          if (existingElement !== null) {
+            warning(labelIdentifier, MessageKind.DUPLICATE_LABEL, [labelName]);
+            warning(existingElement.label,
+                    MessageKind.EXISTING_LABEL, [labelName]);
+          }
+        }
+
+        StatementElement statementElement =
+            new StatementElement(switchCase, enclosingElement);
+        elements[switchCase] = statementElement;
+
+        LabelElement label =
+            new LabelElement(currentLabel, labelName,
+                             statementElement, enclosingElement);
+        elements[labelIdentifier] = label;
+        continueLabels[labelName] = label;
+
+        currentLabel = null;
+      }
+    }
+    statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
-    statementScope.exitLoop();
+    statementScope.exitSwitch();
+
+    // Clean-up unused labels
+    continueLabels.forEach((String key, LabelElement label) {
+      StatementElement statementElement = label.target;
+      SwitchCase switchCase = statementElement.statement;
+      if (!label.isContinueTarget) {
+        elements.remove(switchCase);
+        elements.remove(label.identifier);
+      }
+    });
   }
 
   visitSwitchCase(SwitchCase node) {
-    // TODO(ahe): What about the label?
-    node.expression.accept(this);
+    // The label was handled in [visitSwitchStatement(SwitchStatement)].
+    node.expressions.accept(this);
     node.statements.accept(this);
   }
 
-  visitDefaultCase(DefaultCase node) {
-    // TODO(ahe): What about the label?
-    node.statements.accept(this);
-  }
-
   visitTryStatement(TryStatement node) {
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty() && node.finallyBlock == null) {
       // TODO(ngeoffray): The precise location is
       // node.getEndtoken.next. Adjust when issue #1581 is fixed.
       error(node, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
   }
@@ skipping 308 matching lines @@
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) => library.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }