Reapply "Allow LetCont to bind multiple continuations."

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 106 matching lines @@
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetPrim(this);
 }
 
 
-/// Binding a continuation: 'let cont k(v) = E in E'.  The bound continuation
-/// is in scope in the body and the continuation parameter is in scope in the
-/// continuation body.
-/// During one-pass construction a LetCont with an empty continuation body is
-/// used to represent the one-level context 'let cont k(v) = [] in E'.
+/// Binding continuations.
+///
+/// let cont k0(v0 ...) = E0
+///          k1(v1 ...) = E1
+///          ...
+///   in E
+///
+/// The bound continuations are in scope in the body and the continuation
+/// parameters are in scope in the respective continuation bodies.
+/// During one-pass construction a LetCont whose first continuation has an empty
+/// body is used to represent the one-level context
+/// 'let cont ... k(v) = [] ... in E'.
 class LetCont extends Expression implements InteriorNode {
-  Continuation continuation;
+  List<Continuation> continuations;
   Expression body;
 
-  LetCont(this.continuation, this.body);
+  LetCont(this.continuations, this.body);
 
   Expression plug(Expression expr) {
-    assert(continuation != null && continuation.body == null);
-    return continuation.body = expr;
+    assert(continuations != null &&
+           continuations.isNotEmpty &&
+           continuations.first.body == null);
+    return continuations.first.body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetCont(this);
 }
 
 abstract class Invoke {
   Selector get selector;
   List<Reference<Primitive>> get arguments;
 }
 
 /// Represents a node with a child node, which can be accessed through the
 /// `body` member. A typical usage is when removing a node from the CPS graph:
 ///
 ///     Node child          = node.body;
 ///     InteriorNode parent = node.parent;
 ///
 ///     child.parent = parent;
 ///     parent.body  = child;
-abstract class InteriorNode implements Node {
+abstract class InteriorNode extends Node {
   Expression body;
 }
 
 /// Invoke a static function or static field getter/setter.
 class InvokeStatic extends Expression implements Invoke {
   /// [FunctionElement] or [FieldElement].
   final Entity target;
 
   /**
    * The selector encodes how the function is invoked: number of positional
@@ skipping 431 matching lines @@
   accept(Visitor visitor) => visitor.visitParameter(this);
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with one
 /// parameter and no body is used to represent a function's return continuation.
 /// The return continuation is bound by the Function, not by 'let cont'.
 class Continuation extends Definition<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
   Expression body = null;
 
+  // In addition to a parent pointer to the containing LetCont, continuations
+  // have an index into the list of continuations bound by the LetCont.  This
+  // gives constant-time access to the continuation from the parent.
+  int parent_index;
+
   // A continuation is recursive if it has any recursive invocations.
   bool isRecursive = false;
 
   bool get isReturnContinuation => body == null;
 
   Continuation(this.parameters);
 
   Continuation.retrn() : parameters = <Parameter>[new Parameter(null)];
 
   accept(Visitor visitor) => visitor.visitContinuation(this);
@@ skipping 44 matching lines @@
 class ClosureVariable extends Definition {
   /// Body of code that declares this closure variable.
   ExecutableElement host;
   Entity hint;
 
   ClosureVariable(this.host, this.hint);
 
   accept(Visitor v) => v.visitClosureVariable(this);
 }
 
-class RunnableBody implements InteriorNode {
+class RunnableBody extends InteriorNode {
   Expression body;
   final Continuation returnContinuation;
-  Node parent;
   RunnableBody(this.body, this.returnContinuation);
   accept(Visitor visitor) => visitor.visitRunnableBody(this);
 }
 
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter.
 class FunctionDefinition extends Node
     implements ExecutableDefinition {
   final FunctionElement element;
   /// Mixed list of [Parameter]s and [ClosureVariable]s.
@@ skipping 26 matching lines @@
 
   /// Returns `true` if this function is abstract or external.
   ///
   /// If `true`, [body] and [returnContinuation] are `null` and [localConstants]
   /// is empty.
   bool get isAbstract => body == null;
 }
 
 abstract class Initializer extends Node {}
 
-class FieldInitializer implements Initializer {
+class FieldInitializer extends Initializer {
   final FieldElement element;
   final RunnableBody body;
-  Node parent;
 
   FieldInitializer(this.element, this.body);
   accept(Visitor visitor) => visitor.visitFieldInitializer(this);
 }
 
-class SuperInitializer implements Initializer {
+class SuperInitializer extends Initializer {
   final ConstructorElement target;
   final List<RunnableBody> arguments;
   final Selector selector;
-  Node parent;
   SuperInitializer(this.target, this.arguments, this.selector);
   accept(Visitor visitor) => visitor.visitSuperInitializer(this);
 }
 
 class ConstructorDefinition extends FunctionDefinition {
   final List<Initializer> initializers;
 
   ConstructorDefinition(ConstructorElement element,
                         List<Definition> parameters,
                         RunnableBody body,
@@ skipping 147 matching lines @@
   processLetPrim(LetPrim node) {}
   visitLetPrim(LetPrim node) {
     processLetPrim(node);
     visit(node.primitive);
     visit(node.body);
   }
 
   processLetCont(LetCont node) {}
   visitLetCont(LetCont node) {
     processLetCont(node);
-    visit(node.continuation);
+    node.continuations.forEach(visit);
     visit(node.body);
   }
 
   processInvokeStatic(InvokeStatic node) {}
   visitInvokeStatic(InvokeStatic node) {
     processInvokeStatic(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
@@ skipping 252 matching lines @@
         allocate(param);
       }
     }
   }
 
   void visitFieldInitializer(FieldInitializer node) {
     visit(node.body.body);
   }
 
   void visitSuperInitializer(SuperInitializer node) {
-    node.arguments.forEach((RunnableBody argument) => visit(argument.body));
+    node.arguments.forEach(visit);
   }
 
   void visitLetPrim(LetPrim node) {
     visit(node.body);
     release(node.primitive);
     visit(node.primitive);
   }
 
   void visitLetCont(LetCont node) {
-    visit(node.continuation);
+    node.continuations.forEach(visit);
     visit(node.body);
   }
 
   void visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeContinuation(InvokeContinuation node) {
     node.arguments.forEach(visitReference);
   }
@@ skipping 100 matching lines @@
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }