Implement simple switch statements as nested if/else.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
@@ skipping 1626 matching lines @@
     // in [[body]]; continue(v, ...)
     loopBuilder.add(
         new ir.LetCont(continueCollector.continuation,
             bodyBuilder._root));
 
     // And tie it all together.
     add(new ir.LetCont(breakCollector.continuation, loopBuilder._root));
     environment = breakCollector.environment;
   }
 
+  void buildSimpleSwitch(JumpTarget target,
+                         ir.Primitive value,
+                         List<SwitchCaseInfo> cases,
+                         SwitchCaseInfo defaultCase,
+                         Element error,
+                         SourceInformation sourceInformation) {
+    assert(isOpen);
+    JumpCollector join = new ForwardJumpCollector(environment, target: target);
+
+    IrBuilder casesBuilder = makeDelimitedBuilder();
+    casesBuilder.state.breakCollectors.add(join);
+    for (SwitchCaseInfo caseInfo in cases) {

[asgerf, 2015/06/19 12:47:34]

Anonymize buildRight? I don't understand the name anyway.

buildConditionFrom(int index) => (IrBuilder builder) {
  ...
}

[Kevin Millikin (Google), 2015/06/19 12:59:52]

Yeah, that's how I wrote it in my head, but I wanted to put a return type
annotation for some reason.  It's 2015 and we are still repeating C's
"declaration mimics use" mistake.

I'm happy to change it as you suggest!

+      buildConditionFrom(int index) {
+        ir.Primitive buildRight(IrBuilder builder) {
+          ir.Primitive comparison = builder.addPrimitive(
+              new ir.Identical(value, caseInfo.constants[index]));
+          return (index == caseInfo.constants.length - 1)
+              ? comparison
+              : builder.buildLogicalOperator(
+                  comparison, buildConditionFrom(index + 1), isLazyOr: true);
+        }
+        return buildRight;
+      }
+
+      ir.Primitive condition = buildConditionFrom(0)(casesBuilder);
+      IrBuilder thenBuilder = makeDelimitedBuilder();
+      caseInfo.buildBody(thenBuilder);
+      if (thenBuilder.isOpen) {
+        // It is a runtime error to reach the end of a switch case, unless
+        // it is the last case.
+        if (caseInfo == cases.last && defaultCase == null) {
+          thenBuilder.jumpTo(join);
+        } else {
+          ir.Primitive exception = thenBuilder._buildInvokeStatic(
+              error,
+              new Selector.fromElement(error),
+              <ir.Primitive>[],
+              sourceInformation);
+          thenBuilder.buildThrow(exception);
+        }
+      }
+
+      ir.Continuation thenContinuation = new ir.Continuation([]);
+      thenContinuation.body = thenBuilder._root;
+      ir.Continuation elseContinuation = new ir.Continuation([]);
+      casesBuilder.add(
+          new ir.LetCont.many(<ir.Continuation>[elseContinuation,
+                                                thenContinuation],
+              new ir.Branch(new ir.IsTrue(condition),
+                            thenContinuation,
+                            elseContinuation)));

[asgerf, 2015/06/19 12:47:34]

The rule that the first continuation of LetCont becomes the "current" node to
continue on is quite subtle. I was confused here for a while because I couldn't
see any obvious indicator that 'else' would be continued in the next iteration.

Not specific to this CL at all, but I'm wondering if we can make that nicer
somehow.

[Kevin Millikin (Google), 2015/06/19 12:59:52]

There is a comment everywhere else, I'll duplicate it here.

Only one should have a null body, so we could use that as an indicator and allow
them to be in whatever order is natural but that's subtle too.

+    }
+
+    if (defaultCase != null) {
+      defaultCase.buildBody(casesBuilder);
+    }
+    if (casesBuilder.isOpen) casesBuilder.jumpTo(join);
+
+    casesBuilder.state.breakCollectors.removeLast();
+
+    if (!join.isEmpty) {
+      add(new ir.LetCont(join.continuation, casesBuilder._root));
+      environment = join.environment;
+    } else if (casesBuilder._root != null) {
+      add(casesBuilder._root);
+      _current = casesBuilder._current;
+      environment = casesBuilder.environment;
+    } else {
+      // The translation of the cases did not emit any code.
+    }
+  }
+
   /// Creates a try-statement.
   ///
   /// [tryInfo] provides information on local variables declared and boxed
   /// within this try statement.
   /// [buildTryBlock] builds the try block.
   /// [catchClauseInfos] provides access to the catch type, exception variable,
   /// and stack trace variable, and a function for building the catch block.
   void buildTry(
       {TryStatementInfo tryStatementInfo,
        SubbuildFunction buildTryBlock,
@@ skipping 867 matching lines @@
   final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.type,
                    this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }
+
+class SwitchCaseInfo {
+  final List<ir.Primitive> constants = <ir.Primitive>[];
+  final SubbuildFunction buildBody;
+
+  SwitchCaseInfo(this.buildBody);
+
+  void addConstant(ir.Primitive constant) => constants.add(constant);
+}