Change the collection of continuation jumps.

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 484 matching lines @@
 /// Invoke a continuation in tail position.
 class InvokeContinuation extends Expression {
   Reference<Continuation> continuation;
   List<Reference<Primitive>> arguments;
 
   // An invocation of a continuation is recursive if it occurs in the body of
   // the continuation itself.
   bool isRecursive;
 
   InvokeContinuation(Continuation cont, List<Primitive> args,
-                     {recursive: false})
+                     {this.isRecursive: false})
       : continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args),
-        isRecursive = recursive {
-    assert(cont.parameters == null ||
-        cont.parameters.length == args.length);
-    if (recursive) cont.isRecursive = true;
+        arguments = _referenceList(args) {
+    assert(cont.parameters == null || cont.parameters.length == args.length);
+    if (isRecursive) cont.isRecursive = true;
   }
 
   /// A continuation invocation whose target and arguments will be filled
   /// in later.
   ///
   /// Used as a placeholder for a jump whose target is not yet created
   /// (e.g., in the translation of break and continue).
-  InvokeContinuation.uninitialized({recursive: false})
+  InvokeContinuation.uninitialized({this.isRecursive: false})
       : continuation = null,
-        arguments = null,
-        isRecursive = recursive;
+        arguments = null;
 
   accept(Visitor visitor) => visitor.visitInvokeContinuation(this);
 }
 
 /// The base class of things which can be tested and branched on.
 abstract class Condition extends Node {
 }
 
 class IsTrue extends Condition {
   final Reference<Primitive> value;
@@ skipping 121 matching lines @@
   values.ConstantValue get constant => null;
 
   accept(Visitor visitor) => visitor.visitReifyTypeVar(this);
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final GenericType type;
   final List<Reference<Primitive>> values;
 
-  LiteralList(this.type, Iterable<Primitive> values)
+  LiteralList(this.type, List<Primitive> values)
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 }
 
 class LiteralMapEntry {
   final Reference<Primitive> key;
   final Reference<Primitive> value;
 
   LiteralMapEntry(Primitive key, Primitive value)
@@ skipping 41 matching lines @@
 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 isRecursive;
 
   bool get isReturnContinuation => body == null;
 
-  Continuation(this.parameters);
+  Continuation(this.parameters, {this.isRecursive: false});
 
   Continuation.retrn() : parameters = <Parameter>[new Parameter(null)];
 
   accept(Visitor visitor) => visitor.visitContinuation(this);
 }
 
 abstract class ExecutableDefinition implements Node {
   RunnableBody get body;
   Element get element;
 
@@ skipping 796 matching lines @@
 
   void visitReadTypeVariable(ReadTypeVariable node) {
     visitReference(node.target);
   }
 
   @override
   visitTypeExpression(TypeExpression node) {
     node.arguments.forEach(visitReference);
   }
 }