dart2js cps: Refactor CallExpressions into Primitives.

pkg/compiler/lib/src/cps_ir/cps_fragment.dart

 // Copyright (c) 2015, 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 cps_ir.cps_fragment;
 
 import 'cps_ir_nodes.dart';
 import '../constants/values.dart';
 import '../universe/selector.dart' show Selector;
 import '../types/types.dart' show TypeMask;
@@ skipping 105 matching lines @@
   Primitive invokeBuiltin(BuiltinMethod method,
                           Primitive receiver,
                           List<Primitive> arguments,
                           {bool receiverIsNotNull: false}) {
     ApplyBuiltinMethod apply =
         new ApplyBuiltinMethod(method, receiver, arguments, sourceInformation);
     apply.receiverIsNotNull = receiverIsNotNull;
     return letPrim(apply);
   }
 
-  /// Inserts an invocation. binds its continuation, and returns the
-  /// continuation parameter (i.e. the return value of the invocation).
-  ///
-  /// The continuation body becomes the new hole.
-  Parameter invokeMethod(Primitive receiver,
+  /// Inserts an invocation and returns a primitive holding the returned value.
+  Primitive invokeMethod(Primitive receiver,
                          Selector selector,
                          TypeMask mask,
                          List<Primitive> arguments) {
-    Continuation cont = new Continuation(<Parameter>[new Parameter(null)]);
-    InvokeMethod invoke =
-      new InvokeMethod(receiver, selector, mask, arguments, cont,
-                       sourceInformation);
-    put(new LetCont(cont, invoke));
-    context = cont;
-    return cont.parameters.single;
+    return letPrim(new InvokeMethod(receiver, selector, mask, arguments,
+        sourceInformation));
   }
 
-  /// Inserts an invocation. binds its continuation, and returns the
-  /// continuation parameter (i.e. the return value of the invocation).
-  ///
-  /// The continuation body becomes the new hole.
-  Parameter invokeStatic(FunctionElement target, List<Primitive> arguments) {
-    Continuation cont = new Continuation(<Parameter>[new Parameter(null)]);
-    InvokeStatic invoke =
-      new InvokeStatic(target, new Selector.fromElement(target), arguments,
-                       cont, sourceInformation);
-    put(new LetCont(cont, invoke));
-    context = cont;
-    return cont.parameters.single;
+  /// Inserts an invocation and returns a primitive holding the returned value.
+  Primitive invokeStatic(FunctionElement target, List<Primitive> arguments) {
+    return letPrim(new InvokeStatic(target, new Selector.fromElement(target),
+        arguments, sourceInformation));
   }
 
   /// Inserts an invocation to a static function that throws an error.
   ///
   /// This closes the fragment; no more nodes may be added.
   void invokeStaticThrower(FunctionElement target, List<Primitive> arguments) {
     invokeStatic(target, arguments);
     put(new Unreachable());
   }
 
@@ skipping 81 matching lines @@
   ///   // Build the fail branch
   ///   cps.insideContinuation(fail)
   ///      ..invokeStaticThrower(...);
   ///
   ///   // Go to the happy branch
   ///   cps.invokeContinuation(cont..)
   ///
   Continuation letCont([List<Parameter> parameters]) {
     if (parameters == null) parameters = <Parameter>[];
     Continuation cont = new Continuation(parameters);
+    bindContinuation(cont);
+    return cont;
+  }
+
+  /// Binds an existing continuation at this position.
+  ///
+  /// The LetCont body becomes the new hole.
+  void bindContinuation(Continuation cont) {
     LetCont let = new LetCont(cont, null);
     put(let);
     context = let;
-    return cont;
+  }
+
+  /// Inlines [target] at the current position, substituting the provided
+  /// arguments.
+  ///
+  /// Returns a primitive containing the function's return value.
+  ///
+  /// The new hole is the the point after [target] has returned. The fragment
+  /// remains open, even if [target] never returns.
+  ///
+  /// The [target] function is destroyed and should not be reused.
+  Primitive inlineFunction(FunctionDefinition target,
+                           Primitive thisArgument,
+                           List<Primitive> arguments,
+                           {Entity hint}) {
+    if (thisArgument != null) {
+      target.thisParameter.replaceUsesWith(thisArgument);
+    }
+    for (int i = 0; i < arguments.length; ++i) {
+      target.parameters[i].replaceUsesWith(arguments[i]);
+    }
+    Continuation returnCont = target.returnContinuation;
+    bindContinuation(returnCont);
+    put(target.body);
+    Parameter returnValue = returnCont.parameters.single;
+    returnValue.hint = hint;
+    context = returnCont;
+    return returnValue;
   }
 
   /// Returns a fragment whose context is the body of the given continuation.
   ///
   /// Does not change the state of this CPS fragment.
   ///
   /// Useful for building the body of a continuation created using [letCont].
   CpsFragment insideContinuation(Continuation cont) {
     return new CpsFragment(sourceInformation, cont);
   }
@@ skipping 45 matching lines @@
   }
 }
 
 /// Removes [node], unlinking all its references and replaces it with [newNode].
 void destroyAndReplace(Expression node, Expression newNode) {
   InteriorNode parent = node.parent;
   RemovalVisitor.remove(node);
   parent.body = newNode;
   newNode.parent = parent;
 }