Revert "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 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'.
+/// 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'.
 class LetCont extends Expression implements InteriorNode {
-  List<Continuation> continuations;
+  Continuation continuation;
   Expression body;
 
-  LetCont(this.continuations, this.body);
+  LetCont(this.continuation, this.body);
 
   Expression plug(Expression expr) {
-    assert(continuations != null &&
-           continuations.isNotEmpty &&
-           continuations.first.body == null);
-    return continuations.first.body = expr;
+    assert(continuation != null && continuation.body == null);
+    return continuation.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 extends Node {
+abstract class InteriorNode implements 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 extends InteriorNode {
+class RunnableBody implements 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 extends Initializer {
+class FieldInitializer implements Initializer {
   final FieldElement element;
   final RunnableBody body;
+  Node parent;
 
   FieldInitializer(this.element, this.body);
   accept(Visitor visitor) => visitor.visitFieldInitializer(this);
 }
 
-class SuperInitializer extends Initializer {
+class SuperInitializer implements 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);
-    node.continuations.forEach(visit);
+    visit(node.continuation);
     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(visit);
+    node.arguments.forEach((RunnableBody argument) => visit(argument.body));
   }
 
   void visitLetPrim(LetPrim node) {
     visit(node.body);
     release(node.primitive);
     visit(node.primitive);
   }
 
   void visitLetCont(LetCont node) {
-    node.continuations.forEach(visit);
+    visit(node.continuation);
     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);
   }
 }