Implement nested switches and missing switch continue targets.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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 fasta.body_builder;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 248 matching lines @@
   void ignore(Unhandled value) {
     pop();
   }
 
   void enterSwitchScope() {
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = scope;
   }
 
   void exitSwitchScope() {
-    switchScope = pop();
+    Scope outerSwitchScope = pop();
+    if (switchScope.unclaimedForwardDeclarations != null) {
+      switchScope.unclaimedForwardDeclarations
+          .forEach((String name, Builder builder) {
+        if (outerSwitchScope == null) {
+          addCompileTimeError(-1, "Label not found: '$name'.");
+        } else {
+          outerSwitchScope.forwardDeclareLabel(name, builder);
+        }
+      });
+    }
+    switchScope = outerSwitchScope;
   }
 
   @override
   JumpTarget createJumpTarget(JumpTargetKind kind, int charOffset) {
     return new JumpTarget(kind, functionNestingLevel, member, charOffset);
   }
 
   @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
@@ skipping 1493 matching lines @@
     Identifier name = pop();
     VariableDeclaration variable =
         new VariableDeclaration(name.name, isFinal: true);
     push(new FunctionDeclaration(
         variable, new FunctionNode(new InvalidStatement())));
     scope[variable.name] = new KernelVariableBuilder(
         variable, member ?? classBuilder ?? library, uri);
     enterLocalScope();
   }
 
+  void enterFunction() {
+    debugEvent("enterFunction");
+    functionNestingLevel++;
+    push(switchScope ?? NullValue.SwitchScope);
+    switchScope = null;
+  }
+
+  void exitFunction() {
+    debugEvent("exitFunction");
+    functionNestingLevel--;
+    switchScope = pop();
+  }
+
   @override
   void beginFunction(Token token) {
     debugEvent("beginFunction");
-    functionNestingLevel++;
+    enterFunction();
   }
 
   @override
   void beginUnnamedFunction(Token token) {
     debugEvent("beginUnnamedFunction");
-    functionNestingLevel++;
+    enterFunction();
   }
 
   @override
   void endFunction(Token getOrSet, Token endToken) {
     debugEvent("Function");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     if (functionNestingLevel != 0) {
       exitLocalScope();
     }
     FormalParameters formals = pop();
     List<TypeParameter> typeParameters = pop();
     push(formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)));
-    functionNestingLevel--;
   }
 
   @override
   void endFunctionDeclaration(Token token) {
     debugEvent("FunctionDeclaration");
     FunctionNode function = pop();
     exitLocalScope();
     FunctionDeclaration declaration = pop();
     function.returnType = pop() ?? const DynamicType();
     pop(); // Modifiers.
+    exitFunction();
     declaration.function = function;
     function.parent = declaration;
     push(declaration);
   }
 
   @override
   void endUnnamedFunction(Token token) {
     debugEvent("UnnamedFunction");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
+    exitFunction();
     List<TypeParameter> typeParameters = pop();
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier));
     push(new FunctionExpression(function));
-    functionNestingLevel--;
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
     debugEvent("DoWhileStatement");
     Expression condition = popForValue();
     Statement body = popStatement();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
@@ skipping 181 matching lines @@
           labels.add(labelOrExpression);
         } else {
           expressions.add(toValue(labelOrExpression));
         }
       }
     }
     assert(scope == switchScope);
     for (Label label in labels) {
       if (scope.hasLocalLabel(label.name)) {
         // TODO(ahe): Should validate this is a goto target and not duplicated.
+        scope.claimLabel(label.name);
       } else {
         scope.declareLabel(label.name, createGotoTarget(firstToken.charOffset));
       }
     }
     push(expressions);
     push(labels);
     enterLocalScope();
   }
 
   @override
   void handleSwitchCase(
       int labelCount,
       int expressionCount,
       Token defaultKeyword,
       int statementCount,
       Token firstToken,
       Token endToken) {
     debugEvent("SwitchCase");
     Block block = popBlock(statementCount);
     exitLocalScope();
     List<Label> labels = pop();
     List<Expression> expressions = pop();
-    push(new SwitchCase(expressions, block, isDefault: defaultKeyword != null));
+    push(new SwitchCase(expressions, block, isDefault: defaultKeyword != null)
+      ..fileOffset = firstToken.charOffset);
     push(labels);
   }
 
   @override
   void endSwitchStatement(Token switchKeyword, Token endToken) {
     debugEvent("SwitchStatement");
     // Do nothing. Handled by [endSwitchBlock].
   }
 
   @override
@@ skipping 75 matching lines @@
         push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
             "Target of continue must be a label.", continueKeyword.charOffset));
         return;
       }
       if (target == null) {
         if (switchScope == null) {
           push(buildCompileTimeErrorStatement(
               "Can't find label '$name'.", continueKeyword.next.charOffset));
           return;
         }
-        switchScope.declareLabel(
+        switchScope.forwardDeclareLabel(
             identifier.name, target = createGotoTarget(identifier.fileOffset));
       }
-      if (target.isGotoTarget) {
+      if (target.isGotoTarget &&
+          target.functionNestingLevel == functionNestingLevel) {
         ContinueSwitchStatement statement = new ContinueSwitchStatement(null);
         target.addGoto(statement);
         push(statement);
         return;
       }
     }
     if (target == null) {
       push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
           "No target of continue.", continueKeyword.charOffset));
     } else if (!target.isContinueTarget) {
@@ skipping 568 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }