dart2js: CPS translation of switches with continue to their labels.

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 '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 148 matching lines @@
     if (hasExtraArgument) _continuationEnvironment.extend(null, null);
   }
 
   /// Construct a collector for collecting only return jumps.
   ///
   /// There is no jump target, it is implicitly the exit from the function.
   /// There is no environment at the destination.
   JumpCollector.retrn(this._continuation)
       : _continuationEnvironment = null, target = null;
 
+  /// Construct a collector for collecting goto jumps.
+  ///
+  /// There is no continuation or environment at the destination.
+  JumpCollector.goto(this.target) : _continuationEnvironment = null;
+
   /// True if the collector has not recorded any jumps to its continuation.
   bool get isEmpty;
 
   /// The continuation encapsulated by this collector.
   ir.Continuation get continuation;
 
   /// The compile-time environment to be used for translating code in the body
   /// of the continuation.
   Environment get environment;
 
@@ skipping 235 matching lines @@
   void addJump(IrBuilder builder,
       [ir.Primitive value, SourceInformation sourceInformation]) {
     isEmpty = false;
     builder.add(new ir.InvokeContinuation(continuation, <ir.Primitive>[value],
         isEscapingTry: isEscapingTry,
         sourceInformation: sourceInformation));
     builder._current = null;
   }
 }
 
+/// Collect 'goto' jumps, continue to a labeled case from within a switch.
+///
+/// These jumps are unrestricted within the switch.  They can be forward or
+/// backward.  They are implemented by assigning to a state variable.
+class GotoJumpCollector extends JumpCollector {
+  bool isEmpty = true;
+  final ir.Continuation continuation = null;
+  final Environment environment = null;
+
+  int _stateVariableIndex;
+  int _stateValue;
+  JumpCollector _breakJoin;
+
+  GotoJumpCollector(JumpTarget target, this._stateVariableIndex,
+      this._stateValue, this._breakJoin) : super.goto(target);
+
+  void addJump(IrBuilder builder,
+      [ir.Primitive value, SourceInformation sourceInformation]) {
+    isEmpty = false;
+    ir.Primitive constant = builder.buildIntegerConstant(_stateValue);
+    builder.environment.index2value[_stateVariableIndex] = constant;
+    builder.jumpTo(_breakJoin);
+  }
+}
+
 /// Function for building a node in the context of the current builder.
 typedef ir.Node BuildFunction(node);
 
 /// Function for building nodes in the context of the provided [builder].
 typedef ir.Node SubbuildFunction(IrBuilder builder);
 
 /// Mixin that provides encapsulated access to nested builders.
 abstract class IrBuilderMixin<N> {
   IrBuilder _irBuilder;
 
@@ skipping 91 matching lines @@
   final ExecutableElement executableContext;
   ThisParameterLocal(this.executableContext);
   String get name => 'this';
   toString() => 'ThisParameterLocal($executableContext)';
 }
 
 /// The IR builder maintains an environment and an IR fragment.
 ///
 /// The IR fragment is an expression with a hole in it. The hole represents
 /// the focus where new expressions can be added. The fragment is implemented
-/// by [_root] which is the root of the expression and [_current] which is the
+/// by [root] which is the root of the expression and [_current] which is the
 /// expression that immediately contains the hole. Not all expressions have a
 /// hole (e.g., invocations, which always occur in tail position, do not have a
 /// hole). Expressions with a hole have a plug method.
 ///
 /// The environment maintains the reaching definition of each local variable,
 /// including some synthetic locals such as [TypeVariableLocal].
 ///
 /// Internally, IR builders also maintains a [JumpCollector] stack and tracks
 /// which variables are currently boxed or held in a mutable local variable.
 class IrBuilder {
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
 
   final IrBuilderSharedState state;
 
   /// A map from variable indexes to their values.
   ///
   /// [BoxLocal]s map to their box. [LocalElement]s that are boxed are not
   /// in the map; look up their [BoxLocal] instead.
   Environment environment;
 
   /// A map from mutable local variables to their [ir.MutableVariable]s.
   ///
   /// Mutable variables are treated as boxed.  Writes to them are observable
   /// side effects.
   Map<Local, ir.MutableVariable> mutableVariables;
 
-  ir.Expression _root = null;
+  ir.Expression root = null;
   ir.Expression _current = null;
 
   GlobalProgramInformation get program => state.program;
 
   IrBuilder(GlobalProgramInformation program,
             BackendConstantEnvironment constants,
             ExecutableElement currentElement)
     : state = new IrBuilderSharedState(program, constants, currentElement),
       environment = new Environment.empty(),
       mutableVariables = <Local, ir.MutableVariable>{};
@@ skipping 33 matching lines @@
   /// mutable variable.
   void removeMutableVariable(Local local) {
     mutableVariables.remove(local);
   }
 
   /// Gets the [MutableVariable] containing the value of [local].
   ir.MutableVariable getMutableVariable(Local local) {
     return mutableVariables[local];
   }
 
-  bool get isOpen => _root == null || _current != null;
+  bool get isOpen => root == null || _current != null;
 
   List<ir.Primitive> buildFunctionHeader(Iterable<Local> parameters,
                                         {ClosureScope closureScope,
                                          ClosureEnvironment env}) {
     _createThisParameter();
     _enterClosureEnvironment(env);
     _enterScope(closureScope);
     parameters.forEach(_createFunctionParameter);
     return _parameters;
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
   ir.Parameter _createLocalParameter(Local local) {
     ir.Parameter parameter = new ir.Parameter(local);
     _parameters.add(parameter);
     environment.extend(local, parameter);
     return parameter;
   }
 
   /// Plug an expression into the 'hole' in the context being accumulated.  The
   /// empty context (just a hole) is represented by root (and current) being
   /// null.  Since the hole in the current context is filled by this function,
   /// the new hole must be in the newly added expression---which becomes the
   /// new value of current.
   void add(ir.Expression expr) {
     assert(isOpen);
-    if (_root == null) {
-      _root = _current = expr;
+    if (root == null) {
+      root = _current = expr;
     } else {
       _current = _current.plug(expr);
     }
   }
 
   /// Create and add a new [LetPrim] for [primitive].
   ir.Primitive addPrimitive(ir.Primitive primitive) {
     add(new ir.LetPrim(primitive));
     return primitive;
   }
@@ skipping 127 matching lines @@
     elseBuilder.jumpTo(join, elseValue);
 
     // Build the term
     //   let cont join(x, ..., result) = [] in
     //   let cont then() = [[thenPart]]; join(v, ...)
     //        and else() = [[elsePart]]; join(v, ...)
     //   in
     //     if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
-    thenContinuation.body = thenBuilder._root;
-    elseContinuation.body = elseBuilder._root;
+    thenContinuation.body = thenBuilder.root;
+    elseContinuation.body = elseBuilder.root;
     add(new ir.LetCont(join.continuation,
             new ir.LetCont.two(thenContinuation, elseContinuation,
                 new ir.Branch.strict(condition,
                                      thenContinuation,
                                      elseContinuation))));
     environment = join.environment;
     return environment.discard(1);
   }
 
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = buildNullConstant();
     add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
   }
 
-  /// Create a [ir.FunctionDefinition] using [_root] as the body.
+  /// Create a [ir.FunctionDefinition] using [root] as the body.
   ///
   /// The protocol for building a function is:
   /// 1. Call [buildFunctionHeader].
   /// 2. Call `buildXXX` methods to build the body.
   /// 3. Call [makeFunctionDefinition] to finish.
   ir.FunctionDefinition makeFunctionDefinition() {
     _ensureReturn();
     return new ir.FunctionDefinition(
         state.currentElement,
         state.thisParameter,
         state.functionParameters,
         state.returnContinuation,
-        _root);
+        root);
   }
 
   /// Create a invocation of the [method] on the super class where the call
   /// structure is defined [callStructure] and the argument values are defined
   /// by [arguments].
   ir.Primitive buildSuperMethodInvocation(
       MethodElement method,
       CallStructure callStructure,
       List<ir.Primitive> arguments,
       {SourceInformation sourceInformation}) {
@@ skipping 261 matching lines @@
       result = new ir.LetCont(join.continuation, result);
     }
 
     // The then or else term root could be null, but not both.  If there is
     // a join then an InvokeContinuation was just added to both of them.  If
     // there is no join, then at least one of them is closed and thus has a
     // non-null root by the definition of the predicate isClosed.  In the
     // case that one of them is null, it must be the only one that is open
     // and thus contains the new hole in the context.  This case is handled
     // after the branch is plugged into the current hole.
-    thenContinuation.body = thenBuilder._root;
-    elseContinuation.body = elseBuilder._root;
+    thenContinuation.body = thenBuilder.root;
+    elseContinuation.body = elseBuilder.root;
 
     add(result);
     if (join == null) {
       // At least one subexpression is closed.
       if (thenBuilder.isOpen) {
-        if (thenBuilder._root != null) _current = thenBuilder._current;
+        if (thenBuilder.root != null) _current = thenBuilder._current;
         environment = thenBuilder.environment;
       } else if (elseBuilder.isOpen) {
-        if (elseBuilder._root != null) _current = elseBuilder._current;
+        if (elseBuilder.root != null) _current = elseBuilder._current;
         environment = elseBuilder.environment;
       } else {
         _current = null;
       }
     } else {
       environment = join.environment;
     }
   }
 
   void jumpTo(JumpCollector collector,
@@ skipping 105 matching lines @@
     } else {
       updateBuilder = innerBodyBuilder;
     }
     updateBuilder._enterForLoopUpdate(closureScope, loopVariables);
     buildUpdate(updateBuilder);
     if (updateBuilder.isOpen) updateBuilder.jumpTo(loop);
     // Connect the inner and outer body builders.  This is done only after
     // it is guaranteed that the updateBuilder has a non-empty term.
     if (hasContinues) {
       outerBodyBuilder.add(new ir.LetCont(continueCollector.continuation,
-          innerBodyBuilder._root));
-      continueCollector.continuation.body = updateBuilder._root;
+          innerBodyBuilder.root));
+      continueCollector.continuation.body = updateBuilder.root;
     } else {
-      outerBodyBuilder.add(innerBodyBuilder._root);
+      outerBodyBuilder.add(innerBodyBuilder.root);
     }
 
     // Create loop exit and body entry continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
-    bodyContinuation.body = outerBodyBuilder._root;
+    bodyContinuation.body = outerBodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
             new ir.Branch.strict(condition,
                                  bodyContinuation,
                                  exitContinuation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
-      exitContinuation.body = exitBuilder._root;
+      exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
       add(letBreak);
       environment = breakCollector.environment;
     } else {
       add(branch);
     }
   }
 
   /// Creates a for-in loop, `for (v in e) b`.
   ///
@@ skipping 122 matching lines @@
     state.continueCollectors.removeLast();
     if (bodyBuilder.isOpen) bodyBuilder.jumpTo(loop);
 
     // Create body entry and loop exit continuations and a branch to them.
     //
     // let cont exit() = [ ]
     //      and body() = <<BODY>>
     // in branch condition (body, exit)
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
-    bodyContinuation.body = bodyBuilder._root;
+    bodyContinuation.body = bodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
             new ir.Branch.strict(condition,
                                  bodyContinuation,
                                  exitContinuation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
-      exitContinuation.body = exitBuilder._root;
+      exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
       add(letBreak);
       environment = breakCollector.environment;
     } else {
       add(branch);
     }
   }
 
   /// Creates a while loop in which the condition and body are created by
   /// [buildCondition] and [buildBody], respectively.
@@ skipping 38 matching lines @@
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
     assert(state.continueCollectors.last == loop);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
     if (bodyBuilder.isOpen) bodyBuilder.jumpTo(loop);
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
-    bodyContinuation.body = bodyBuilder._root;
+    bodyContinuation.body = bodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
             new ir.Branch.strict(condition,
                                  bodyContinuation,
                                  exitContinuation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
-      exitContinuation.body = exitBuilder._root;
+      exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
       add(letBreak);
       environment = breakCollector.environment;
     } else {
       add(branch);
     }
   }
 
 
   /// Creates a do-while loop.
@@ skipping 46 matching lines @@
     //   let cont exit() = break(v, ...)
     //        and repeat() = loop(v, ...)
     //   in branch cond (repeat, exit)
     IrBuilder continueBuilder = loopBuilder.makeDelimitedBuilder();
     continueBuilder.environment = continueCollector.environment;
     ir.Primitive condition = buildCondition(continueBuilder);
 
     ir.Continuation exitContinuation = new ir.Continuation([]);
     IrBuilder exitBuilder = continueBuilder.makeDelimitedBuilder();
     exitBuilder.jumpTo(breakCollector);
-    exitContinuation.body = exitBuilder._root;
+    exitContinuation.body = exitBuilder.root;
     ir.Continuation repeatContinuation = new ir.Continuation([]);
     IrBuilder repeatBuilder = continueBuilder.makeDelimitedBuilder();
     repeatBuilder.jumpTo(loop);
-    repeatContinuation.body = repeatBuilder._root;
+    repeatContinuation.body = repeatBuilder.root;
 
     continueBuilder.add(
         new ir.LetCont.two(exitContinuation, repeatContinuation,
             new ir.Branch.strict(condition,
                                  repeatContinuation,
                                  exitContinuation)));
-    continueCollector.continuation.body = continueBuilder._root;
+    continueCollector.continuation.body = continueBuilder.root;
 
     // Construct the loop continuation (i.e., the body and condition).
     // <Loop> =
     // let cont continue(x, ...) =
     //   <Continue>
     // in [[body]]; continue(v, ...)
     loopBuilder.add(
         new ir.LetCont(continueCollector.continuation,
-            bodyBuilder._root));
+            bodyBuilder.root));
 
     // And tie it all together.
-    add(new ir.LetCont(breakCollector.continuation, loopBuilder._root));
+    add(new ir.LetCont(breakCollector.continuation, loopBuilder.root));
     environment = breakCollector.environment;
   }
 
-  void buildSimpleSwitch(JumpTarget target,
-                         ir.Primitive value,
+  void buildSimpleSwitch(JumpCollector join,
                          List<SwitchCaseInfo> cases,
-                         SwitchCaseInfo defaultCase,
-                         Element error,
-                         SourceInformation sourceInformation) {
-    assert(isOpen);
-    JumpCollector join = new ForwardJumpCollector(environment, target: target);
-
+                         SubbuildFunction buildDefaultBody) {
     IrBuilder casesBuilder = makeDelimitedBuilder();
-    casesBuilder.state.breakCollectors.add(join);
     for (SwitchCaseInfo caseInfo in cases) {
-      buildConditionsFrom(int index) => (IrBuilder builder) {
-        ir.Primitive comparison = builder.buildIdentical(
-            value, caseInfo.constants[index]);
-        return (index == caseInfo.constants.length - 1)
-            ? comparison
-            : builder.buildLogicalOperator(
-                comparison, buildConditionsFrom(index + 1), isLazyOr: true);
-      };
-
-      ir.Primitive condition = buildConditionsFrom(0)(casesBuilder);
+      ir.Primitive condition = caseInfo.buildCondition(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;
+      thenContinuation.body = thenBuilder.root;
       ir.Continuation elseContinuation = new ir.Continuation([]);
-      // A LetCont.many term has a hole as the body of the first listed
+      // A LetCont.two term has a hole as the body of the first listed
       // continuation, to be plugged by the translation.  Therefore put the
       // else continuation first.
       casesBuilder.add(
           new ir.LetCont.two(elseContinuation, thenContinuation,
               new ir.Branch.strict(condition,
                                    thenContinuation,
                                    elseContinuation)));
     }
 
-    if (defaultCase != null) {
-      defaultCase.buildBody(casesBuilder);
+    if (buildDefaultBody == null) {
+      casesBuilder.jumpTo(join);
+    } else {
+      buildDefaultBody(casesBuilder);
     }
-    if (casesBuilder.isOpen) casesBuilder.jumpTo(join);
-
-    casesBuilder.state.breakCollectors.removeLast();
 
     if (!join.isEmpty) {
-      add(new ir.LetCont(join.continuation, casesBuilder._root));
+      add(new ir.LetCont(join.continuation, casesBuilder.root));
       environment = join.environment;
-    } else if (casesBuilder._root != null) {
-      add(casesBuilder._root);
+    } 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.
     }
   }
 
   /// Utility function to translate try/catch into the IR.
   ///
   /// The translation treats try/finally and try/catch/finally as if they
@@ skipping 41 matching lines @@
       assert(catchBuilder.isInMutableVariable(variable));
       ir.Primitive value = catchBuilder.buildLocalGet(variable);
       // After this point, the variables that were boxed on entry to the try
       // are no longer treated as mutable.
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     List<ir.Parameter> catchParameters = buildCatch(catchBuilder, join);
     ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
-    catchContinuation.body = catchBuilder._root;
+    catchContinuation.body = catchBuilder.root;
     tryCatchBuilder.add(
-        new ir.LetHandler(catchContinuation, tryBuilder._root));
+        new ir.LetHandler(catchContinuation, tryBuilder.root));
 
-    leaveTryCatch(this, join, tryCatchBuilder._root);
+    leaveTryCatch(this, join, tryCatchBuilder.root);
   }
 
   /// Translates a try/catch.
   ///
   /// [variables] provides information on local variables declared and boxed
   /// within the try body.
   /// [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 buildTryCatch(TryStatementInfo variables,
@@ skipping 83 matching lines @@
         if (clause.exceptionVariable != null) {
           clauseBuilder.declareLocalVariable(clause.exceptionVariable,
               initialValue: exceptionParameter);
         }
         if (clause.stackTraceVariable != null) {
           clauseBuilder.declareLocalVariable(clause.stackTraceVariable,
               initialValue: traceParameter);
         }
         clause.buildCatchBlock(clauseBuilder);
         if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
-        return clauseBuilder._root;
+        return clauseBuilder.root;
       }
 
       // Expand multiple catch clauses into an explicit if/then/else.  Iterate
       // them in reverse so the current block becomes the next else block.
       ir.Expression catchBody = (catchAll == null)
           ? new ir.Rethrow()
           : buildCatchClause(catchAll);
       for (CatchClauseInfo clause in catchClauseInfos.reversed) {
         ir.Continuation thenContinuation = new ir.Continuation([]);
         ir.Continuation elseContinuation = new ir.Continuation([]);
         thenContinuation.body = buildCatchClause(clause);
         elseContinuation.body = catchBody;
 
         // Build the type test guarding this clause. We can share the
         // environment with the nested builder because this part cannot mutate
         // it.
         IrBuilder checkBuilder = builder.makeDelimitedBuilder(environment);
         ir.Primitive typeMatches =
             checkBuilder.buildTypeOperator(exceptionParameter,
                 clause.type,
                 isTypeTest: true);
         checkBuilder.add(new ir.LetCont.two(thenContinuation, elseContinuation,
             new ir.Branch.strict(typeMatches,
                                  thenContinuation,
                                  elseContinuation)));
-        catchBody = checkBuilder._root;
+        catchBody = checkBuilder.root;
       }
       builder.add(catchBody);
 
       return <ir.Parameter>[exceptionParameter, traceParameter];
     }
 
     void leaveTryCatch(IrBuilder builder, JumpCollector join,
                        ir.Expression body) {
       // Add the binding for the join-point continuation and continue the
       // translation in its body.
@@ skipping 84 matching lines @@
                        ir.Expression body) {
       // Build a list of continuations for jumps from the try block and
       // duplicate the finally code before jumping to the actual target.
       List<ir.Continuation> exits = <ir.Continuation>[join.continuation];
       void addJump(JumpCollector newCollector,
                    JumpCollector originalCollector) {
         if (newCollector.isEmpty) return;
         IrBuilder builder = makeDelimitedBuilder(newCollector.environment);
         buildFinallyBlock(builder);
         if (builder.isOpen) builder.jumpTo(originalCollector);
-        newCollector.continuation.body = builder._root;
+        newCollector.continuation.body = builder.root;
         exits.add(newCollector.continuation);
       }
       for (int i = 0; i < newBreaks.length; ++i) {
         addJump(newBreaks[i], savedBreaks[i]);
       }
       for (int i = 0; i < newContinues.length; ++i) {
         addJump(newContinues[i], savedContinues[i]);
       }
       if (!newReturn.isEmpty) {
         IrBuilder builder = makeDelimitedBuilder(newReturn.environment);
         ir.Primitive value = builder.environment.discard(1);
         buildFinallyBlock(builder);
         if (builder.isOpen) builder.buildReturn(value: value);
-        newReturn.continuation.body = builder._root;
+        newReturn.continuation.body = builder.root;
         exits.add(newReturn.continuation);
       }
       builder.add(new ir.LetCont.many(exits, body));
       builder.environment = join.environment;
       buildFinallyBlock(builder);
     }
 
     _helpBuildTryCatch(variables, enterTry, buildTryBlock, leaveTry,
         buildCatch, leaveTryCatch);
   }
@@ skipping 106 matching lines @@
   void buildLabeledStatement({SubbuildFunction buildBody,
                               JumpTarget target}) {
     JumpCollector join = new ForwardJumpCollector(environment, target: target);
     IrBuilder innerBuilder = makeDelimitedBuilder();
     innerBuilder.state.breakCollectors.add(join);
     buildBody(innerBuilder);
     innerBuilder.state.breakCollectors.removeLast();
     bool hasBreaks = !join.isEmpty;
     if (hasBreaks) {
       if (innerBuilder.isOpen) innerBuilder.jumpTo(join);
-      add(new ir.LetCont(join.continuation, innerBuilder._root));
+      add(new ir.LetCont(join.continuation, innerBuilder.root));
       environment = join.environment;
-    } else if (innerBuilder._root != null) {
-      add(innerBuilder._root);
+    } else if (innerBuilder.root != null) {
+      add(innerBuilder.root);
       _current = innerBuilder._current;
       environment = innerBuilder.environment;
     } else {
       // The translation of the body did not emit any CPS term.
     }
   }
 
   // Build(BreakStatement L, C) = C[InvokeContinuation(...)]
   //
   // The continuation and arguments are filled in later after translating
@@ skipping 115 matching lines @@
     // for the right subexpression, and a three-way join continuation.
     JumpCollector join =
         new ForwardJumpCollector(environment, hasExtraArgument: true);
     emptyBuilder.jumpTo(join, leftBool);
     rightTrueBuilder.jumpTo(join, rightTrue);
     rightFalseBuilder.jumpTo(join, rightFalse);
     ir.Continuation leftTrueContinuation = new ir.Continuation([]);
     ir.Continuation leftFalseContinuation = new ir.Continuation([]);
     ir.Continuation rightTrueContinuation = new ir.Continuation([]);
     ir.Continuation rightFalseContinuation = new ir.Continuation([]);
-    rightTrueContinuation.body = rightTrueBuilder._root;
-    rightFalseContinuation.body = rightFalseBuilder._root;
+    rightTrueContinuation.body = rightTrueBuilder.root;
+    rightFalseContinuation.body = rightFalseBuilder.root;
     // The right subexpression has two continuations.
     rightBuilder.add(
         new ir.LetCont.two(rightTrueContinuation, rightFalseContinuation,
             new ir.Branch.strict(rightValue,
                                  rightTrueContinuation,
                                  rightFalseContinuation)));
     // Depending on the operator, the left subexpression's continuations are
     // either the right subexpression or an invocation of the join-point
     // continuation.
     if (isLazyOr) {
-      leftTrueContinuation.body = emptyBuilder._root;
-      leftFalseContinuation.body = rightBuilder._root;
+      leftTrueContinuation.body = emptyBuilder.root;
+      leftFalseContinuation.body = rightBuilder.root;
     } else {
-      leftTrueContinuation.body = rightBuilder._root;
-      leftFalseContinuation.body = emptyBuilder._root;
+      leftTrueContinuation.body = rightBuilder.root;
+      leftFalseContinuation.body = emptyBuilder.root;
     }
 
     add(new ir.LetCont(join.continuation,
             new ir.LetCont.two(leftTrueContinuation, leftFalseContinuation,
                 new ir.Branch.strict(leftValue,
                                      leftTrueContinuation,
                                      leftFalseContinuation))));
     environment = join.environment;
     return environment.discard(1);
   }
@@ skipping 561 matching lines @@
   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 buildCondition;
   final SubbuildFunction buildBody;
 
-  SwitchCaseInfo(this.buildBody);
-
-  void addConstant(ir.Primitive constant) => constants.add(constant);
+  SwitchCaseInfo(this.buildCondition, this.buildBody);
 }