Allow LetCont to bind multiple continuations.

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(k, expression));
+    add(new ir.LetCont(<ir.Continuation>[k], expression));

[asgerf, 2015/01/15 15:29:45]

It may be nicer to introduce a named constructor for the case of multiple
continuations, and preserve the unnamed LetCont constructor for the common case
where there is only one continuation.

E.g.
new ir.LetCont(k, expression)
new ir.LetCont.many([trueCont, falseCont], expression)

Alternatively, the single-continuation constructor could also be named. It would
still be more readable than the pervasive <ir.Continuation>.

     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 117 matching lines @@
     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

[asgerf, 2015/01/15 15:29:45]

'let cont else()' --> 'and cont else()' ?

     //     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(joinContinuation,
-            new ir.LetCont(thenContinuation,
-                new ir.LetCont(elseContinuation,
-                    new ir.Branch(new ir.IsTrue(condition),
-                                  thenContinuation,
-                                  elseContinuation)))));
+    add(new ir.LetCont(<ir.Continuation>[joinContinuation],
+            new ir.LetCont(<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
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = buildNullLiteral();
@@ skipping 222 matching lines @@
     IrBuilder elseBuilder = makeDelimitedBuilder();
     buildThenPart(thenBuilder);
     buildElsePart(elseBuilder);
 
     // Build the term
     // (Result =) let cont then() = [[thenPart]] in
     //            let cont else() = [[elsePart]] in
     //              if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
-    ir.Expression letElse =
-        new ir.LetCont(elseContinuation,
-          new ir.Branch(new ir.IsTrue(condition),
-                        thenContinuation,
-                        elseContinuation));
-    ir.Expression letThen = new ir.LetCont(thenContinuation, letElse);
-    ir.Expression result = letThen;
+    // 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.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(joinContinuation, result);
+      result = new ir.LetCont(<ir.Continuation>[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;
     elseContinuation.body = elseBuilder._root;
 
     add(result);
     if (joinContinuation == null) {
       // At least one subexpression is closed.
       if (thenBuilder.isOpen) {
-        _current =
-            (thenBuilder._root == null) ? letThen : thenBuilder._current;
+        if (thenBuilder._root != null) _current = thenBuilder._current;
         environment = thenBuilder.environment;
       } else if (elseBuilder.isOpen) {
-        _current =
-            (elseBuilder._root == null) ? letElse : elseBuilder._current;
+        if (elseBuilder._root != null) _current = elseBuilder._current;
         environment = elseBuilder.environment;
       } else {
         _current = null;
       }
     }
   }
 
   /// Invoke a join-point continuation that contains arguments for all local
   /// variables.
   ///
@@ skipping 105 matching lines @@
         ? condBuilder.makeRecursiveBuilder()
         : bodyBuilder;
     if (hasBoxedLoopVariables) {
       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(exitContinuation,
-            new ir.LetCont(bodyContinuation,
-                new ir.Branch(new ir.IsTrue(condition),
-                              bodyContinuation,
-                              exitContinuation)));
+        new ir.LetCont(<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);
@@ skipping 12 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(continueContinuation, bodyBuilder._root);
+          new ir.LetCont(<ir.Continuation>[continueContinuation],
+              bodyBuilder._root);
     } else {
       bodyContinuation.body = bodyBuilder._root;
     }
 
     loopContinuation.body = condBuilder._root;
-    add(new ir.LetCont(loopContinuation,
+    add(new ir.LetCont(<ir.Continuation>[loopContinuation],
             new ir.InvokeContinuation(loopContinuation,
                 environment.index2value)));
     if (hasBreaks) {
       _current = branch;
       environment = condBuilder.environment;
       breakCollector.addJump(this);
-      letJoin.continuation = createJoin(environment.length, breakCollector);
+      letJoin.continuations =
+          <ir.Continuation>[createJoin(environment.length, breakCollector)];
       _current = letJoin;
     } else {
       _current = condBuilder._current;
       environment = condBuilder.environment;
     }
   }
 
   /// Creates a for-in loop, `for (v in e) b`.
   ///
   /// [buildExpression] creates the expression, `e`. The variable, `v`, can
@@ skipping 30 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(iteratorInvoked,
+    add(new ir.LetCont(<ir.Continuation>[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(moveNextInvoked,
+    condBuilder.add(new ir.LetCont(<ir.Continuation>[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(currentInvoked,
+    bodyBuilder.add(new ir.LetCont(<ir.Continuation>[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(exitContinuation,
-            new ir.LetCont(bodyContinuation,
-                new ir.Branch(new ir.IsTrue(condition),
-                              bodyContinuation,
-                              exitContinuation)));
+        new ir.LetCont(<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(loopContinuation,
+    add(new ir.LetCont(<ir.Continuation>[loopContinuation],
             new ir.InvokeContinuation(loopContinuation,
                                       environment.index2value)));
     if (hasBreaks) {
       _current = branch;
       environment = condBuilder.environment;
       breakCollector.addJump(this);
-      letJoin.continuation = createJoin(environment.length, breakCollector);
+      letJoin.continuations =
+          <ir.Continuation>[createJoin(environment.length, breakCollector)];
       _current = letJoin;
     } else {
       _current = condBuilder._current;
       environment = condBuilder.environment;
     }
   }
 
   /// Creates a while loop in which the condition and body are created by
   /// [buildCondition] and [buildBody], respectively.
   ///
@@ skipping 33 matching lines @@
     bodyBuilder._buildClosureScopeSetup(closureScope);
     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(exitContinuation,
-            new ir.LetCont(bodyContinuation,
-                new ir.Branch(new ir.IsTrue(condition),
-                              bodyContinuation,
-                              exitContinuation)));
+        new ir.LetCont(<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(loopContinuation,
+    add(new ir.LetCont(<ir.Continuation>[loopContinuation],
             new ir.InvokeContinuation(loopContinuation,
                                       environment.index2value)));
     if (hasBreaks) {
       _current = branch;
       environment = condBuilder.environment;
       breakCollector.addJump(this);
-      letJoin.continuation = createJoin(environment.length, breakCollector);
+      letJoin.continuations =
+          <ir.Continuation>[createJoin(environment.length, breakCollector)];
       _current = letJoin;
     } else {
       _current = condBuilder._current;
       environment = condBuilder.environment;
     }
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
   /// null.
   void buildReturn([ir.Primitive value]) {
@@ skipping 78 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(joinContinuation,
-          new ir.LetCont(thenContinuation,
-            new ir.LetCont(elseContinuation,
+    add(new ir.LetCont(<ir.Continuation>[joinContinuation],
+          new ir.LetCont(<ir.Continuation>[thenContinuation, elseContinuation],
               new ir.Branch(new ir.IsTrue(condition),
                             thenContinuation,
-                            elseContinuation)))));
+                            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.
   ir.Primitive buildTypeOperator(ir.Primitive receiver,
                                  DartType type,
                                  {bool isTypeTest: false,
@@ skipping 58 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(rightTrueContinuation,
-            new ir.LetCont(rightFalseContinuation,
-                new ir.Branch(new ir.IsTrue(rightValue),
-                              rightTrueContinuation,
-                              rightFalseContinuation))));
+        new ir.LetCont(<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(joinContinuation,
-            new ir.LetCont(leftTrueContinuation,
-                new ir.LetCont(leftFalseContinuation,
-                    new ir.Branch(new ir.IsTrue(leftValue),
-                                  leftTrueContinuation,
-                                  leftFalseContinuation)))));
+    add(new ir.LetCont(<ir.Continuation>[joinContinuation],
+            new ir.LetCont(<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.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis() {
@@ skipping 434 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;
 }