dart2js cps: Fuse tear-off and call invocation.

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.
 library dart2js.ir_nodes;
 
 import '../constants/values.dart' as values show ConstantValue;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../types/types.dart' show TypeMask;
@@ skipping 106 matching lines @@
   /// Unlinks this reference from the list of occurrences.
   void unlink() {
     if (previous == null) {
       assert(definition.firstRef == this);
       definition.firstRef = next;
     } else {
       previous.next = next;
     }
     if (next != null) next.previous = previous;
   }
+
+  void changeTo(Definition<T> newDefinition) {

[floitsch, 2015/07/02 18:02:40]

Add a comment.

is this a "replaceWith" ?

[asgerf, 2015/07/03 08:44:46]

I wanted a name that doesn't give the impression that we are doing variable
substitution (i.e. replacing ALL occurrences).

Anyways, I have removed it again since the code that used it now creates a new
reference instead.

+    unlink();
+    definition = newDefinition;
+    previous = null;
+    next = definition.firstRef;
+    if (next != null) next.previous = this;
+    definition.firstRef = this;
+  }
 }
 
 /// Evaluates a primitive and binds it to variable: `let val x = V in E`.
 ///
 /// The bound value is in scope in the body.
 ///
 /// During one-pass construction a LetPrim with an empty body is used to
 /// represent the one-hole context `let val x = V in []`.
 class LetPrim extends Expression implements InteriorNode {
   Primitive primitive;
@@ skipping 122 matching lines @@
   final SourceInformation sourceInformation;
 
   InvokeStatic(this.target,
                this.selector,
                List<Primitive> args,
                Continuation cont,
                [this.sourceInformation])
       : arguments = _referenceList(args),
         continuation = new Reference<Continuation>(cont);
 
+  InvokeStatic.byReference(this.target,
+                           this.selector,
+                           this.arguments,
+                           this.continuation,
+                           [this.sourceInformation]);
+
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 }
 
 /// Invoke a method on an object.
 ///
 /// This includes getters, setters, operators, and index getter/setters.
 ///
 /// Tearing off a method is treated like a getter invocation (getters and
 /// tear-offs cannot be distinguished at compile-time).
 ///
@@ skipping 988 matching lines @@
   const RemovalVisitor();
 
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (const RemovalVisitor()).visit(node);
   }
 }