Make continuations last in CPS IR constructors.

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;
-import '../cps_ir/optimizers.dart';
 import '../dart_types.dart' show DartType, GenericType, TypeVariableType;
 import '../dart2jslib.dart' as dart2js show
     CURRENT_ELEMENT_SPANNABLE,
     InternalErrorFunction,
     invariant;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../universe/universe.dart' show Selector, SelectorKind;
 
 abstract class Node {
@@ skipping 198 matching lines @@
   /// [FunctionElement] or [FieldElement].
   final Entity target;
 
   /**
    * The selector encodes how the function is invoked: number of positional
    * arguments, names used in named arguments. This information is required
    * to build the [StaticCallSiteTypeInformation] for the inference graph.
    */
   final Selector selector;
 
+  final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
-  final List<Reference<Primitive>> arguments;
   final SourceInformation sourceInformation;
 
   InvokeStatic(this.target,
                this.selector,
+               List<Primitive> args,
                Continuation cont,
-               List<Primitive> args,
                this.sourceInformation)
-      : continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args) {
+      : arguments = _referenceList(args),
+        continuation = new Reference<Continuation>(cont) {
     assert(target is ErroneousElement || selector.name == target.name);
   }
 
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 }
 
 /// A [CallingConvention] codifies how arguments are matched to parameters when
 /// emitting code for a function call.
 class CallingConvention {
   final String name;
   const CallingConvention(this.name);
   /// The normal way of calling a Dart function: Positional arguments are
   /// matched with (mandatory and optional) positionals parameters from left to
   /// right and named arguments are matched by name.
   static const CallingConvention DART = const CallingConvention("Dart call");
   /// Intercepted calls have an additional first argument that is the actual
   /// receiver of the call.  See the documentation of [Interceptor] for more
   /// information.
   static const CallingConvention JS_INTERCEPTED =
       const CallingConvention("intercepted JavaScript call");
 }
 
 /// Invoke a method, operator, getter, setter, or index getter/setter.
 /// Converting a method to a function object is treated as a getter invocation.
 class InvokeMethod extends Expression implements Invoke {
   Reference<Primitive> receiver;
   Selector selector;
   CallingConvention callingConvention;
+  final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
-  final List<Reference<Primitive>> arguments;
   final SourceInformation sourceInformation;
 
   InvokeMethod(Primitive receiver,
                Selector selector,
+               List<Primitive> arguments,
                Continuation continuation,
-               List<Primitive> arguments,
                {SourceInformation sourceInformation})
       : this.internal(new Reference<Primitive>(receiver),
                       selector,
+                      _referenceList(arguments),
                       new Reference<Continuation>(continuation),
-                      _referenceList(arguments),
                       sourceInformation);
 
   InvokeMethod.internal(this.receiver,
                         this.selector,
+                        this.arguments,
                         this.continuation,
-                        this.arguments,
                         this.sourceInformation,
                         [this.callingConvention = CallingConvention.DART]) {
     assert(isValid);
   }
 
   /// Returns whether the arguments match the selector under the given calling
   /// convention.
   ///
   /// This check is designed to be used in an assert, as it also checks that the
   /// selector, arguments, and calling convention have meaningful values.
@@ skipping 32 matching lines @@
 /// invocations to intercepted methods, where the effective receiver is instead
 /// passed as a formal parameter.
 ///
 /// When targeting Dart, this instruction is used to represent super calls.
 /// Here, [receiver] must always be a reference to `this`, and [target] must be
 /// a method that is available in the super class.
 class InvokeMethodDirectly extends Expression implements Invoke {
   Reference<Primitive> receiver;
   final Element target;
   final Selector selector;
+  final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
-  final List<Reference<Primitive>> arguments;
 
   InvokeMethodDirectly(Primitive receiver,
                        this.target,
                        this.selector,
-                       Continuation cont,
-                       List<Primitive> args)
+                       List<Primitive> args,
+                       Continuation cont)
       : this.receiver = new Reference<Primitive>(receiver),
-        continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args) {
+          arguments = _referenceList(args),
+          continuation = new Reference<Continuation>(cont) {
     assert(selector != null);
     assert(selector.kind == SelectorKind.CALL ||
            selector.kind == SelectorKind.OPERATOR ||
            (selector.kind == SelectorKind.GETTER && arguments.isEmpty) ||
            (selector.kind == SelectorKind.SETTER && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 2));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 }
 
 /// Non-const call to a constructor. The [target] may be a generative
 /// constructor, factory, or redirecting factory.
 class InvokeConstructor extends Expression implements Invoke {
   final DartType type;
   final FunctionElement target;
+  final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
-  final List<Reference<Primitive>> arguments;
   final Selector selector;
 
   /// The class being instantiated. This is the same as `target.enclosingClass`
   /// and `type.element`.
   ClassElement get targetClass => target.enclosingElement;
 
   /// True if this is an invocation of a factory constructor.
   bool get isFactory => target.isFactoryConstructor;
 
   InvokeConstructor(this.type,
                     this.target,
                     this.selector,
-                    Continuation cont,
-                    List<Primitive> args)
-      : continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args) {
+                    List<Primitive> args,
+                    Continuation cont)
+      : arguments = _referenceList(args),
+        continuation = new Reference<Continuation>(cont) {
     assert(dart2js.invariant(target,
         target.isErroneous ||
         type.isDynamic ||
         type.element == target.enclosingClass.declaration,
         message: "Constructor invocation target is not a constructor: "
                  "$target."));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
@@ skipping 18 matching lines @@
     assert(isTypeTest != null);
   }
 
   bool get isTypeCast => !isTypeTest;
 
   accept(Visitor visitor) => visitor.visitTypeOperator(this);
 }
 
 /// Invoke [toString] on each argument and concatenate the results.
 class ConcatenateStrings extends Expression {
+  final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
-  final List<Reference<Primitive>> arguments;
 
-  ConcatenateStrings(Continuation cont, List<Primitive> args)
-      : continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args);
+  ConcatenateStrings(List<Primitive> args, Continuation cont)
+      : arguments = _referenceList(args),
+        continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
 /// Gets the value from a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  A [LetPrim] with a [GetMutableVariable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
@@ skipping 820 matching lines @@
     processReadTypeVariable(node);
     processReference(node.target);
   }
 
   processTypeExpression(TypeExpression node) {}
   visitTypeExpression(TypeExpression node) {
     processTypeExpression(node);
     node.arguments.forEach(processReference);
   }
 }