Fix lingering switch statement test failures.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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.
 
 import 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 697 matching lines @@
     // Nested invalid types are treated as `dynamic`.
     return const ResolutionDynamicType();
   }
 }
 
 class KernelJumpTarget extends JumpTarget {
   static int index = 0;
 
   /// Pointer to the actual executable statements that a jump target refers to.
   /// If this jump target was not initially constructed with a LabeledStatement,
-  /// this value is identical to originalStatement.
-  // TODO(efortuna): In an ideal world the Node should be some common
-  // interface we create for both ir.Statements and ir.SwitchCase (the
-  // ContinueSwitchStatement's target is a SwitchCase) rather than general
-  // Node. Talking to Asger about this.
+  /// this value is identical to originalStatement. This Node is actually of
+  /// type either ir.Statement or ir.SwitchCase.
   ir.Node targetStatement;
 
   /// The original statement used to construct this jump target.
   /// If this jump target was not initially constructed with a LabeledStatement,
-  /// this value is identical to targetStatement.
+  /// this value is identical to targetStatement. This Node is actually of
+  /// type either ir.Statement or ir.SwitchCase.
   ir.Node originalStatement;
 
+  /// Used to provide unique numbers to labels that would otherwise be duplicate
+  /// if one JumpTarget is inside another.
+  int nestingLevel;
+
   @override
   bool isBreakTarget = false;
 
   @override
   bool isContinueTarget = false;
 
   KernelJumpTarget(this.targetStatement, KernelAstAdapter adapter,
       {bool makeContinueLabel = false}) {
     originalStatement = targetStatement;
     this.labels = <LabelDefinition>[];
     if (targetStatement is ir.WhileStatement ||
         targetStatement is ir.DoStatement ||
         targetStatement is ir.ForStatement ||
         targetStatement is ir.ForInStatement) {
       // Currently these labels are set at resolution on the element itself.
       // Once that gets updated, this logic can change downstream.
       JumpTarget target = adapter.elements
           .getTargetDefinition(adapter.getNode(targetStatement));
       if (target != null) {
         labels.addAll(target.labels);
         isBreakTarget = target.isBreakTarget;
         isContinueTarget = target.isContinueTarget;
       }
     } else if (targetStatement is ir.LabeledStatement) {
       targetStatement = (targetStatement as ir.LabeledStatement).body;
       labels.add(
           new LabelDefinitionX(null, 'L${index++}', this)..setBreakTarget());
       isBreakTarget = true;
     }
+    var originalNode = adapter.getNode(originalStatement);
+    var originalTarget = adapter.elements.getTargetDefinition(originalNode);
+    if (originalTarget != null) {
+      nestingLevel = originalTarget.nestingLevel;
+    } else {
+      nestingLevel = 0;
+    }
 
     if (makeContinueLabel) {
       labels.add(
           new LabelDefinitionX(null, 'L${index++}', this)..setContinueTarget());
       isContinueTarget = true;
     }
   }
 
   @override
   LabelDefinition addLabel(ast.Label label, String labelName) {
@@ skipping 13 matching lines @@
 
   @override
   bool get isTarget => isBreakTarget || isContinueTarget;
 
   @override
   List<LabelDefinition> labels;
 
   @override
   String get name => 'target';
 
-  // TODO(efortuna): In the original version, this nesting level is specified at
-  // jump target construction time, by the resolver. Because these are
-  // instantiated later, we don't have that information. When we move fully over
-  // to the kernel model, we can pass the nesting level in KernelJumpTarget's
-  // constructor.
-  @override
-  int get nestingLevel => 0;
-
   @override
   ast.Node get statement => null;
 
   String toString() => 'Target:$targetStatement';
 }
 
 /// Special [JumpHandler] implementation used to handle continue statements
 /// targeting switch cases.
 class KernelSwitchCaseJumpHandler extends SwitchCaseJumpHandler {
   KernelSwitchCaseJumpHandler(GraphBuilder builder, JumpTarget target,
       ir.SwitchStatement switchStatement, KernelAstAdapter astAdapter)
       : super(builder, target) {
     // The switch case indices must match those computed in
     // [KernelSsaBuilder.buildSwitchCaseConstants].
     // Switch indices are 1-based so we can bypass the synthetic loop when no
     // cases match simply by branching on the index (which defaults to null).
     // TODO
     int switchIndex = 1;
     for (ir.SwitchCase switchCase in switchStatement.cases) {
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }