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 404 matching lines @@
 class LabeledStatementLabelScope implements LabelScope {
   final LabelScope outer;
   final LabelElement label;
   LabeledStatementLabelScope(this.outer, this.label);
   LabelElement lookup(String labelName) {
     if (this.label.labelName == labelName) return label;
     return outer.lookup(labelName);
   }
 }
 
+class SwitchLabelScope implements LabelScope {
+  final LabelScope outer;
+  final Map<String, LabelElement> caseLabels;

[ahe, 2012/03/13 10:17:15]

Add an empty line.

[Lasse Reichstein Nielsen, 2012/03/13 12:09:38]

Done.

+  SwitchLabelScope(this.outer, this.caseLabels);

[ahe, 2012/03/13 10:17:15]

Add an empty line.

[Lasse Reichstein Nielsen, 2012/03/13 12:09:38]

Done.

+  LabelElement lookup(String labelName) {
+    LabelElement result = caseLabels[labelName];
+    if (result !== null) return result;
+    return outer.lookup(labelName);
+  }
+}
+
 class EmptyLabelScope implements LabelScope {
   const EmptyLabelScope();
   LabelElement lookup(String label) => null;
   LabelScope get outer() {
     throw 'internal error: empty label scope has no outer';
   }
 }
 
 class StatementScope {
   LabelScope labels;
   Link<StatementElement> breakTargetStack;
   Link<StatementElement> continueTargetStack;
+  int nestingLevel = 0;
 
   StatementScope()
       : labels = const EmptyLabelScope(),
         breakTargetStack = const EmptyLink<StatementElement>(),
         continueTargetStack = const EmptyLink<StatementElement>();
 
-  LabelElement lookupLabel(String label) => labels.lookup(label);
+  LabelElement lookupLabel(String label) =>
+      labels.lookup(label);
+
   StatementElement currentBreakTarget() =>
     breakTargetStack.isEmpty() ? null : breakTargetStack.head;
+
   StatementElement currentContinueTarget() =>
     continueTargetStack.isEmpty() ? null : continueTargetStack.head;
 
   void enterLabelScope(LabelElement element) {
     labels = new LabeledStatementLabelScope(labels, element);
+    nestingLevel++;
   }
+
   void exitLabelScope() {
+    nestingLevel--;
     labels = labels.outer;
   }
+
   void enterLoop(StatementElement element) {
     breakTargetStack = breakTargetStack.prepend(element);
     continueTargetStack = continueTargetStack.prepend(element);
+    nestingLevel++;
   }
+
   void exitLoop() {
+    nestingLevel--;
     breakTargetStack = breakTargetStack.tail;
     continueTargetStack = continueTargetStack.tail;
   }
+
+  void enterSwitch(StatementElement breakElement,
+                   Map<String, LabelElement> continueElements) {
+    breakTargetStack = breakTargetStack.prepend(breakElement);
+    labels = new SwitchLabelScope(labels, continueElements);
+    nestingLevel++;

[ahe, 2012/03/13 10:17:15]

This seems wrong, but perhaps I'm misunderstanding something. Entering a switch
statement does not affect continue, it only affects break. So isn't this
problematic?

[Lasse Reichstein Nielsen, 2012/03/13 12:09:38]

The switch level doesn't need to be exact, as long as it's different for two
break/continue-target statements if one is inside the other.
I'll add a comment.

+  }
+
+  void exitSwitch() {
+    nestingLevel--;
+    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;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
@@ skipping 13 matching lines @@
     Element result = context.lookup(name);
     if (!inInstanceContext && result != null && result.isInstanceMember()) {
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
   StatementElement getOrCreateStatementElement(Node statement) {
     StatementElement element = mapping[statement];
-    if (element !== null) return element;
-    element = new StatementElement(statement, enclosingElement);
-    mapping[statement] = element;
+    if (element === null) {
+      element = new StatementElement(statement,
+                                     statementScope.nestingLevel,
+                                     enclosingElement);
+      mapping[statement] = element;
+    }
     return element;
   }
 
   inStaticContext(action()) {
     bool wasInstanceContext = inInstanceContext;
     inInstanceContext = false;
     action();
     inInstanceContext = wasInstanceContext;
   }
 
@@ skipping 444 matching lines @@
       }
       target.isBreakTarget = true;
     } else {
       String labelName = node.target.source.slowToString();
       LabelElement label = statementScope.lookupLabel(labelName);
       if (label === null) {
         error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
         return;
       }
       target = label.target;
+      if (!target.statement.isValidBreakTarget()) {
+        error(node.target, MessageKind.INVALID_BREAK, [labelName]);
+        return;

[ahe, 2012/03/13 10:17:15]

Thank you :-)

+      }
       label.setBreakTarget();
       mapping[node.target] = label;
     }
     mapping[node] = target;
   }
 
   visitContinueStatement(ContinueStatement node) {
     StatementElement target;
     if (node.target === null) {
       target = statementScope.currentContinueTarget();
@@ skipping 68 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);

[ahe, 2012/03/13 10:17:15]

Nit: I'm not digging this method. I would prefer if it always created a
statement element.

[Lasse Reichstein Nielsen, 2012/03/13 12:09:38]

The problem is that we want to create a StatementElement for a statement as soon
as we know that it's a potential break target.
For a labeled statement, that happens when we encounter the LabelledStatement.
If the statement happens to be a switch or loop, we want to reuse that
StatementElement when we get to the switch/loop.

So this function checks if a StatementElement is already attached to the Node,
if so, returns that, and if not, creates one.
Suggestions for another approach?

+    Map<String, LabelElement> continueLabels = <LabelElement>{};
+    Link<SwitchCase> cases = node.cases.nodes;
+    while (!cases.isEmpty()) {
+      SwitchCase switchCase = cases.head;
+      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.lookupLabel(labelName);
+          if (existingElement !== null) {
+            warning(labelIdentifier, MessageKind.DUPLICATE_LABEL, [labelName]);
+            warning(existingElement.label,
+                    MessageKind.EXISTING_LABEL, [labelName]);
+          }
+        }
+
+        StatementElement statementElement =
+            new StatementElement(switchCase,
+                                 statementScope.nestingLevel,
+                                 enclosingElement);
+        mapping[switchCase] = statementElement;
+
+        LabelElement label =
+            new LabelElement(labelIdentifier, labelName,

[ahe, 2012/03/13 10:17:15]

I don't understand the mental model for this. The label is enclosing the
statement, yet the statementElement doesn't see the label element in its chain
of enclosing elements.

[Lasse Reichstein Nielsen, 2012/03/13 12:09:38]

Are you referring to enclosingElement? I have assumed that this refers to the
function, not to syntax inside the function.

+                             statementElement, enclosingElement);
+        mapping[labelIdentifier] = label;
+        continueLabels[labelName] = label;
+      }
+      cases = cases.tail;
+      if (switchCase.defaultKeyword !== null && !cases.isEmpty()) {
+        error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
+      }
+    }
+    statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
-    statementScope.exitLoop();
+    statementScope.exitSwitch();
+
+    // Clean-up unused labels
+    continueLabels.forEach((String key, LabelElement label) {

[ahe, 2012/03/13 10:17:15]

Wouldn't it better to set a bit on the label?

[Lasse Reichstein Nielsen, 2012/03/13 12:09:38]

The bit is set. This is pure cleanup. We know that we won't be needing these
labels and statement elements after this, since they are unreferenced. 
We could just let it all stay, and check flags later, but that's a waste of
memory.

+      StatementElement statementElement = label.target;
+      SwitchCase switchCase = statementElement.statement;
+      if (!label.isContinueTarget) {
+        mapping.remove(switchCase);
+        mapping.remove(label.label);
+      }
+    });
   }
 
   visitSwitchCase(SwitchCase node) {
-    // TODO(ahe): What about the label?
-    node.expression.accept(this);
+    // The label was handled in [visitSwitchStatement(SwitchStatement)].
+    node.expressions.accept(this);
     visitIn(node.statements, new BlockScope(context));
   }
 
-  visitDefaultCase(DefaultCase node) {
-    // TODO(ahe): What about the label?
-    visitIn(node.statements, new BlockScope(context));
-  }
-
   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 477 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";
   }
 }