Implement switch statement, without the "complex switch statement" (aka switch statement with conti…

pkg/compiler/lib/src/kernel/kernel_visitor.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 832 matching lines @@
           internalError(node, "no parent");
         }
       }
     }
 
     return result;
   }
 
   @override
   ir.BoolLiteral visitLiteralBool(LiteralBool node) {
-    return new ir.BoolLiteral(node.value);
+    return associateNode(new ir.BoolLiteral(node.value), node);
   }
 
   @override
   ir.DoubleLiteral visitLiteralDouble(LiteralDouble node) {
-    return new ir.DoubleLiteral(node.value);
+    return associateNode(new ir.DoubleLiteral(node.value), node);
   }
 
   @override
   ir.IntLiteral visitLiteralInt(LiteralInt node) {
-    return new ir.IntLiteral(node.value);
+    return associateNode(new ir.IntLiteral(node.value), node);
   }
 
   @override
   ir.ListLiteral visitLiteralList(LiteralList node) {
     // TODO(ahe): Type arguments.
     List<ir.Expression> elements = <ir.Expression>[];
     for (Expression element in node.elements.nodes) {
       elements.add(visitForValue(element));
     }
     return associateNode(
@@ skipping 30 matching lines @@
   }
 
   @override
   ir.NullLiteral visitLiteralNull(LiteralNull node) {
     return new ir.NullLiteral();
   }
 
   @override
   ir.Expression visitLiteralString(LiteralString node) {
     if (node.dartString == null) return new ir.InvalidExpression();
-    return new ir.StringLiteral(node.dartString.slowToString());
+    return associateNode(new ir.StringLiteral(node.dartString.slowToString()),
+        node);
   }
 
   @override
   ir.SymbolLiteral visitLiteralSymbol(LiteralSymbol node) {
     var result = new ir.SymbolLiteral(node.slowNameString);
     return associateNode(result, node);
   }
 
   @override
   visitMetadata(Metadata node) {
@@ skipping 109 matching lines @@
       ir.SwitchCase irCase = casesIterator.current;
       List<ir.Statement> statements = <ir.Statement>[];
       bool hasVariableDeclaration = false;
       for (Statement statement in caseNode.statements.nodes) {
         if (buildStatement(statement, statements)) {
           hasVariableDeclaration = true;
         }
       }
       if (statements.isEmpty || fallsThrough(statements.last)) {
         if (isLastCase) {
-          statements.add(new ir.BreakStatement(
-              getBreakTarget(elements.getTargetDefinition(node))));
+          if (!caseNode.isDefaultCase) {
+            statements.add(new ir.BreakStatement(
+                getBreakTarget(elements.getTargetDefinition(node))));
+          }
         } else {
           statements.add(new ir.ExpressionStatement(new ir.Throw(
               new ir.ConstructorInvocation(
                   kernel.getFallThroughErrorConstructor(),
                   new ir.Arguments.empty()))));
         }
       }
       ir.Statement body = new ir.Block(statements);
       irCase.body = body;
       body.parent = irCase;
@@ skipping 196 matching lines @@
     return buildCompoundAssignment(
         node,
         buildIndexAccessor(receiver, index),
         kernel.irName(operator.selectorName, currentElement),
         visitForValue(rhs));
   }
 
   @override
   ir.InvocationExpression visitConstConstructorInvoke(
       NewExpression node, ConstructedConstantExpression constant, _) {
-    return buildConstructorInvoke(node, isConst: true);
+    return associateNode(buildConstructorInvoke(node, isConst: true), node);
   }
 
   @override
   visitConstantGet(Send node, ConstantExpression constant, _) {
     // TODO(ahe): This method is never called. Is it a bug in semantic visitor?
     return internalError(node, "ConstantGet");
   }
 
   @override
   visitConstantInvoke(Send node, ConstantExpression constant,
@@ skipping 1599 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }