Incorporate some code review comments.

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 '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 379 matching lines @@
       _root = _current = expr;
     } else {
       _current = _current.plug(expr);
     }
   }
 
   ir.Primitive _continueWithExpression(ir.Expression build(ir.Continuation k)) {
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression expression = build(k);
-    add(new ir.LetCont(<ir.Continuation>[k], expression));
+    add(new ir.LetCont(k, expression));
     return v;
   }
 
   ir.Primitive _buildInvokeStatic(Element element,
                                   Selector selector,
                                   List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, arguments));
   }
@@ skipping 116 matching lines @@
     thenBuilder.environment.extend(null, thenValue);
     elseBuilder.environment.extend(null, elseValue);
     JumpCollector jumps = new JumpCollector(null);
     jumps.addJump(thenBuilder);
     jumps.addJump(elseBuilder);
     ir.Continuation joinContinuation =
         createJoin(environment.length + 1, jumps);
 
     // Build the term
     //   let cont join(x, ..., result) = [] in
-    //   let cont then() = [[thenPart]]; join(v, ...) in
-    //   let cont else() = [[elsePart]]; join(v, ...) 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;
-    add(new ir.LetCont(<ir.Continuation>[joinContinuation],
-            new ir.LetCont(<ir.Continuation>[thenContinuation,
-                                             elseContinuation],
+    add(new ir.LetCont(joinContinuation,
+            new ir.LetCont.many(<ir.Continuation>[thenContinuation,
+                                                  elseContinuation],
                 new ir.Branch(new ir.IsTrue(condition),
                               thenContinuation,
                               elseContinuation))));
     return (thenValue == elseValue)
         ? thenValue
         : joinContinuation.parameters.last;
   }
 
   /**
    * Add an explicit `return null` for functions that don't have a return
@@ skipping 223 matching lines @@
                void buildElsePart(IrBuilder builder)) {
     assert(isOpen);
 
     // The then and else parts are delimited.
     IrBuilder thenBuilder = makeDelimitedBuilder();
     IrBuilder elseBuilder = makeDelimitedBuilder();
     buildThenPart(thenBuilder);
     buildElsePart(elseBuilder);
 
     // Build the term
-    // (Result =) let cont then() = [[thenPart]] in
-    //            let cont else() = [[elsePart]] in
+    // (Result =) let cont then() = [[thenPart]]
+    //                 and else() = [[elsePart]]
+    //            in
     //              if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     // If exactly one of the then and else continuation bodies is open (i.e.,
     // the other one has an exit on all paths), then Continuation.plug expects
     // that continuation to be listed first.  Arbitrarily use [then, else]
     // order otherwise.
     List<ir.Continuation> arms = !thenBuilder.isOpen && elseBuilder.isOpen
         ? <ir.Continuation>[elseContinuation, thenContinuation]
         : <ir.Continuation>[thenContinuation, elseContinuation];
 
     ir.Expression result =
-        new ir.LetCont(arms,
+        new ir.LetCont.many(arms,
             new ir.Branch(new ir.IsTrue(condition),
                           thenContinuation,
                           elseContinuation));
 
     ir.Continuation joinContinuation;  // Null if there is no join.
     if (thenBuilder.isOpen && elseBuilder.isOpen) {
       // There is a join-point continuation.  Build the term
       // 'let cont join(x, ...) = [] in Result' and plug invocations of the
       // join-point continuation into the then and else continuations.
       JumpCollector jumps = new JumpCollector(null);
       jumps.addJump(thenBuilder);
       jumps.addJump(elseBuilder);
       joinContinuation = createJoin(environment.length, jumps);
-      result = new ir.LetCont(<ir.Continuation>[joinContinuation], result);
+      result = new ir.LetCont(joinContinuation, 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;
@@ skipping 128 matching lines @@
       updateBuilder._migrateLoopVariables(closureScope);
     }
     buildUpdate(updateBuilder);
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
-        new ir.LetCont(<ir.Continuation>[exitContinuation, bodyContinuation],
+        new ir.LetCont.many(<ir.Continuation>[exitContinuation,
+                                              bodyContinuation],
             new ir.Branch(new ir.IsTrue(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.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letJoin;
     if (hasBreaks) {
       letJoin = new ir.LetCont(null, branch);
       condBuilder.add(letJoin);
@@ skipping 15 matching lines @@
       JumpCollector backEdges = new JumpCollector(null);
       backEdges.addJump(updateBuilder);
       invokeFullJoin(loopContinuation, backEdges, recursive: true);
     }
 
     // Fill in the body and possible continue continuation bodies.  Do this
     // only after it is guaranteed that they are not empty.
     if (hasContinues) {
       continueContinuation.body = updateBuilder._root;
       bodyContinuation.body =
-          new ir.LetCont(<ir.Continuation>[continueContinuation],
+          new ir.LetCont(continueContinuation,
               bodyBuilder._root);
     } else {
       bodyContinuation.body = bodyBuilder._root;
     }
 
     loopContinuation.body = condBuilder._root;
-    add(new ir.LetCont(<ir.Continuation>[loopContinuation],
+    add(new ir.LetCont(loopContinuation,
             new ir.InvokeContinuation(loopContinuation,
                 environment.index2value)));
     if (hasBreaks) {
       _current = branch;
       environment = condBuilder.environment;
       breakCollector.addJump(this);
       letJoin.continuations =
           <ir.Continuation>[createJoin(environment.length, breakCollector)];
       _current = letJoin;
     } else {
@@ skipping 38 matching lines @@
     // }
 
     // The condition and body are delimited.
     IrBuilder condBuilder = makeRecursiveBuilder();
 
     ir.Primitive expressionReceiver = buildExpression(this);
     List<ir.Primitive> emptyArguments = new List<ir.Primitive>();
 
     ir.Parameter iterator = new ir.Parameter(null);
     ir.Continuation iteratorInvoked = new ir.Continuation([iterator]);
-    add(new ir.LetCont(<ir.Continuation>[iteratorInvoked],
+    add(new ir.LetCont(iteratorInvoked,
         new ir.InvokeMethod(expressionReceiver,
             new Selector.getter("iterator", null), iteratorInvoked,
             emptyArguments)));
 
     ir.Parameter condition = new ir.Parameter(null);
     ir.Continuation moveNextInvoked = new ir.Continuation([condition]);
-    condBuilder.add(new ir.LetCont(<ir.Continuation>[moveNextInvoked],
+    condBuilder.add(new ir.LetCont(moveNextInvoked,
         new ir.InvokeMethod(iterator,
             new Selector.call("moveNext", null, 0),
             moveNextInvoked, emptyArguments)));
 
     JumpCollector breakCollector = new JumpCollector(target);
     JumpCollector continueCollector = new JumpCollector(target);
     state.breakCollectors.add(breakCollector);
     state.continueCollectors.add(continueCollector);
 
     IrBuilder bodyBuilder = condBuilder.makeDelimitedBuilder();
     bodyBuilder._buildClosureScopeSetup(closureScope);
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
 
     ir.Parameter currentValue = new ir.Parameter(null);
     ir.Continuation currentInvoked = new ir.Continuation([currentValue]);
-    bodyBuilder.add(new ir.LetCont(<ir.Continuation>[currentInvoked],
+    bodyBuilder.add(new ir.LetCont(currentInvoked,
         new ir.InvokeMethod(iterator, new Selector.getter("current", null),
             currentInvoked, emptyArguments)));
     if (Elements.isLocal(variableElement)) {
       bodyBuilder.buildLocalSet(variableElement, currentValue);
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
       bodyBuilder.buildStaticSet(
           variableElement, variableSelector, currentValue);
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       bodyBuilder.buildDynamicSet(receiver, variableSelector, currentValue);
     }
 
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
     assert(state.continueCollectors.last == continueCollector);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
-        new ir.LetCont(<ir.Continuation>[exitContinuation, bodyContinuation],
+        new ir.LetCont.many(<ir.Continuation>[exitContinuation,
+                                              bodyContinuation],
             new ir.Branch(new ir.IsTrue(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.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letJoin;
     if (hasBreaks) {
       letJoin = new ir.LetCont(null, branch);
       condBuilder.add(letJoin);
       condBuilder._current = branch;
     } else {
       condBuilder.add(branch);
     }
     ir.Continuation loopContinuation =
         new ir.Continuation(condBuilder._parameters);
     if (bodyBuilder.isOpen) continueCollector.addJump(bodyBuilder);
     invokeFullJoin(
         loopContinuation, continueCollector, recursive: true);
     bodyContinuation.body = bodyBuilder._root;
 
     loopContinuation.body = condBuilder._root;
-    add(new ir.LetCont(<ir.Continuation>[loopContinuation],
+    add(new ir.LetCont(loopContinuation,
             new ir.InvokeContinuation(loopContinuation,
                                       environment.index2value)));
     if (hasBreaks) {
       _current = branch;
       environment = condBuilder.environment;
       breakCollector.addJump(this);
       letJoin.continuations =
           <ir.Continuation>[createJoin(environment.length, breakCollector)];
       _current = letJoin;
     } else {
@@ skipping 44 matching lines @@
     assert(state.continueCollectors.last == continueCollector);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
-        new ir.LetCont(<ir.Continuation>[exitContinuation, bodyContinuation],
+        new ir.LetCont.many(<ir.Continuation>[exitContinuation,
+                                              bodyContinuation],
             new ir.Branch(new ir.IsTrue(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.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letJoin;
     if (hasBreaks) {
       letJoin = new ir.LetCont(null, branch);
       condBuilder.add(letJoin);
       condBuilder._current = branch;
     } else {
       condBuilder.add(branch);
     }
     ir.Continuation loopContinuation =
         new ir.Continuation(condBuilder._parameters);
     if (bodyBuilder.isOpen) continueCollector.addJump(bodyBuilder);
     invokeFullJoin(loopContinuation, continueCollector, recursive: true);
     bodyContinuation.body = bodyBuilder._root;
 
     loopContinuation.body = condBuilder._root;
-    add(new ir.LetCont(<ir.Continuation>[loopContinuation],
+    add(new ir.LetCont(loopContinuation,
             new ir.InvokeContinuation(loopContinuation,
                                       environment.index2value)));
     if (hasBreaks) {
       _current = branch;
       environment = condBuilder.environment;
       breakCollector.addJump(this);
       letJoin.continuations =
           <ir.Continuation>[createJoin(environment.length, breakCollector)];
       _current = letJoin;
     } else {
@@ skipping 86 matching lines @@
     }
 
     ir.Constant trueConstant = makeBoolConstant(true);
     ir.Constant falseConstant = makeBoolConstant(false);
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
 
-    add(new ir.LetCont(<ir.Continuation>[joinContinuation],
-          new ir.LetCont(<ir.Continuation>[thenContinuation, elseContinuation],
+    add(new ir.LetCont(joinContinuation,
+          new ir.LetCont.many(<ir.Continuation>[thenContinuation,
+                                                elseContinuation],
               new ir.Branch(new ir.IsTrue(condition),
                             thenContinuation,
                             elseContinuation))));
     return resultParameter;
   }
 
   /// Creates a type test or type cast of [receiver] against [type].
   ///
   /// Set [isTypeTest] to `true` to create a type test and furthermore set
   /// [isNotCheck] to `true` to create a negated type test.
@@ skipping 61 matching lines @@
     ir.Continuation joinContinuation =
         createJoin(environment.length + 1, jumps);
     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;
     // The right subexpression has two continuations.
     rightBuilder.add(
-        new ir.LetCont(<ir.Continuation>[rightTrueContinuation,
-                                         rightFalseContinuation],
+        new ir.LetCont.many(<ir.Continuation>[rightTrueContinuation,
+                                              rightFalseContinuation],
             new ir.Branch(new ir.IsTrue(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;
     } else {
       leftTrueContinuation.body = rightBuilder._root;
       leftFalseContinuation.body = emptyBuilder._root;
     }
 
-    add(new ir.LetCont(<ir.Continuation>[joinContinuation],
-            new ir.LetCont(<ir.Continuation>[leftTrueContinuation,
-                                             leftFalseContinuation],
+    add(new ir.LetCont(joinContinuation,
+            new ir.LetCont.many(<ir.Continuation>[leftTrueContinuation,
+                                                  leftFalseContinuation],
                 new ir.Branch(new ir.IsTrue(leftValue),
                               leftTrueContinuation,
                               leftFalseContinuation))));
     // There is always a join parameter for the result value, because it
     // is different on at least two paths.
     return joinContinuation.parameters.last;
   }
 
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
@@ skipping 439 matching lines @@
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 /// Information about which variables are captured in a closure.
 /// This is used by the [DartIrBuilder] instead of [ClosureScope] and
 /// [ClosureEnvironment].
 abstract class ClosureVariableInfo {
   Iterable<Local> get capturedVariables;
 }