dart2js cps: Use definitions by default, not references.

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

 // Copyright (c) 2014, 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.cps_ir.shrinking_reductions;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /**
@@ skipping 185 matching lines @@
     InvokeContinuation invoke = cont.firstRef.parent;
     InteriorNode invokeParent = invoke.parent;
     Expression body = cont.body;
 
     // Replace the invocation with the continuation body.
     invokeParent.body = body;
     body.parent = invokeParent;
     cont.body = null;
 
     // Substitute the invocation argument for the continuation parameter.
-    for (int i = 0; i < invoke.arguments.length; i++) {
+    for (int i = 0; i < invoke.argumentRefs.length; i++) {
       Parameter param = cont.parameters[i];
-      Primitive argument = invoke.arguments[i].definition;
+      Primitive argument = invoke.argument(i);
       param.replaceUsesWith(argument);
       argument.useElementAsHint(param.hint);
       _checkConstantBranchCondition(argument);
     }
 
     // Remove the continuation after inlining it so we can check for eta redexes
     // which may arise after removing the LetCont.
     _removeContinuation(cont);
 
     // Perform bookkeeping on substituted body and scan for new redexes.
@@ skipping 17 matching lines @@
     //    letcont k1 x1 = k0 x1 in E1
     if (!_isEtaCont(task.node)) {
       return;
     }
 
     // Remove the continuation.
     Continuation cont = task.node;
     _removeContinuation(cont);
 
     InvokeContinuation invoke = cont.body;
-    Continuation wrappedCont = invoke.continuation.definition;
+    Continuation wrappedCont = invoke.continuation;
 
     for (int i = 0; i < cont.parameters.length; ++i) {
       wrappedCont.parameters[i].useElementAsHint(cont.parameters[i].hint);
     }
 
     // If the invocation of wrappedCont is escaping, then all invocations of
     // cont will be as well, after the reduction.
     if (invoke.isEscapingTry) {
       Reference current = cont.firstRef;
       while (current != null) {
@@ skipping 16 matching lines @@
     // Perform bookkeeping on removed body and scan for new redexes.
     new _RemovalVisitor(_worklist).visit(cont);
   }
 
   void _reduceBranch(_ReductionTask task) {
     Branch branch = task.node;
     // Replace Branch with InvokeContinuation of one of the targets. When the
     // branch is deleted the other target becomes unreferenced and the chosen
     // target becomes available for eta-cont and further reductions.
     Continuation target;
-    Primitive condition = branch.condition.definition;
+    Primitive condition = branch.condition;
     if (condition is Constant) {
       target = isTruthyConstant(condition.value, strict: branch.isStrictCheck)
-          ? branch.trueContinuation.definition
-          : branch.falseContinuation.definition;
-    } else if (_isBranchTargetOfUselessIf(branch.trueContinuation.definition)) {
-      target = branch.trueContinuation.definition;
+          ? branch.trueContinuation
+          : branch.falseContinuation;
+    } else if (_isBranchTargetOfUselessIf(branch.trueContinuation)) {
+      target = branch.trueContinuation;
     } else {
       return;
     }
 
     InvokeContinuation invoke = new InvokeContinuation(
         target, <Primitive>[]
         // TODO(sra): Add sourceInformation.
         /*, sourceInformation: branch.sourceInformation*/);
     branch.parent.body = invoke;
     invoke.parent = branch.parent;
@@ skipping 24 matching lines @@
 
     Continuation continuation = parameter.parent;
     int index = continuation.parameters.indexOf(parameter);
     assert(index != -1);
     continuation.parameters.removeAt(index);
     parameter.parent = null; // Mark as removed.
 
     // Remove the index'th argument from each invocation.
     for (Reference ref = continuation.firstRef; ref != null; ref = ref.next) {
       InvokeContinuation invoke = ref.parent;
-      Reference<Primitive> argument = invoke.arguments[index];
+      Reference<Primitive> argument = invoke.argumentRefs[index];
       argument.unlink();
-      invoke.arguments.removeAt(index);
+      invoke.argumentRefs.removeAt(index);
       // Removing an argument can create a dead primitive or an eta-redex
       // in case the parent is a continuation that now has matching parameters.
       _checkDeadPrimitive(argument.definition);
       if (invoke.parent is Continuation) {
         _checkEtaCont(invoke.parent);
         _checkUselessBranchTarget(invoke.parent);
       }
     }
 
     // Removing an unused parameter can create an eta-redex, in case the
@@ skipping 95 matching lines @@
 /// Returns true iff the continuation consists of a continuation
 /// invocation, passing on all parameters. Special cases exist (see below).
 bool _isEtaCont(Continuation cont) {
   if (_isRemoved(cont)) return false;
 
   if (!cont.isJoinContinuation || cont.body is! InvokeContinuation) {
     return false;
   }
 
   InvokeContinuation invoke = cont.body;
-  Continuation invokedCont = invoke.continuation.definition;
+  Continuation invokedCont = invoke.continuation;
 
   // Do not eta-reduce return join-points since the direct-style code is worse
   // in the common case (i.e. returns are moved inside `if` branches).
   if (invokedCont.isReturnContinuation) {
     return false;
   }
 
   // Translation to direct style generates different statements for recursive
   // and non-recursive invokes. It should still be possible to apply eta-cont if
   // this is not a self-invocation.
@@ skipping 17 matching lines @@
   //
   // let cont k1(x1) = k0(x0, x1) in E -eta-> E'
   // where E' has k0(x0, v) substituted for each k1(v).
   //
   // HOWEVER, adding continuation parameters is unlikely to be an optimization
   // since it duplicates assignments used in direct-style to implement parameter
   // passing.
   //
   // TODO(kmillikin): find real occurrences of these patterns, and see if they
   // can be optimized.
-  if (cont.parameters.length != invoke.arguments.length) {
+  if (cont.parameters.length != invoke.argumentRefs.length) {
     return false;
   }
 
   // TODO(jgruber): Linear in the parameter count. Can be improved to near
   // constant time by using union-find data structure.
   for (int i = 0; i < cont.parameters.length; i++) {
-    if (invoke.arguments[i].definition != cont.parameters[i]) {
+    if (invoke.argument(i) != cont.parameters[i]) {
       return false;
     }
   }
 
   return true;
 }
 
 Expression _unfoldDeadRefinements(Expression node) {
   while (node is LetPrim) {
     LetPrim let = node;
     Primitive prim = let.primitive;
     if (prim.hasAtLeastOneUse || prim is! Refinement) return node;
     node = node.next;
   }
   return node;
 }
 
 bool _isBranchRedex(Branch branch) {
-  return _isUselessIf(branch) || branch.condition.definition is Constant;
+  return _isUselessIf(branch) || branch.condition is Constant;
 }
 
 bool _isBranchTargetOfUselessIf(Continuation cont) {
   // A useless-if has an empty then and else branch, e.g. `if (cond);`.
   //
   // Detect T or F in
   //
   //     let cont Join() = ...
   //       in let cont T() = Join()
   //                   F() = Join()
   //         in branch condition T F
   //
   if (!cont.hasExactlyOneUse) return false;
   Node use = cont.firstRef.parent;
   if (use is! Branch) return false;
   return _isUselessIf(use);
 }
 
 bool _isUselessIf(Branch branch) {
-  Continuation trueCont = branch.trueContinuation.definition;
+  Continuation trueCont = branch.trueContinuation;
   Expression trueBody = _unfoldDeadRefinements(trueCont.body);
   if (trueBody is! InvokeContinuation) return false;
-  Continuation falseCont = branch.falseContinuation.definition;
+  Continuation falseCont = branch.falseContinuation;
   Expression falseBody = _unfoldDeadRefinements(falseCont.body);
   if (falseBody is! InvokeContinuation) return false;
   InvokeContinuation trueInvoke = trueBody;
   InvokeContinuation falseInvoke = falseBody;
-  if (trueInvoke.continuation.definition !=
-      falseInvoke.continuation.definition) {
+  if (trueInvoke.continuation !=
+      falseInvoke.continuation) {
     return false;
   }
   // Matching zero arguments should be adequate, since isomorphic true and false
   // invocations should result in redundant phis which are removed elsewhere.
   //
   // Note that the argument lists are not necessarily the same length here,
   // because we could be looking for new redexes in the middle of performing a
   // dead parameter reduction, where some but not all of the invocations have
   // been rewritten.  In that case, we will find the redex (once) after both
   // of these invocations have been rewritten.
-  return trueInvoke.arguments.isEmpty && falseInvoke.arguments.isEmpty;
+  return trueInvoke.argumentRefs.isEmpty && falseInvoke.argumentRefs.isEmpty;
 }
 
 bool _isDeadParameter(Parameter parameter) {
   if (_isParameterRemoved(parameter)) return false;
 
   // We cannot remove function parameters as an intraprocedural optimization.
   if (parameter.parent is! Continuation || parameter.hasAtLeastOneUse) {
     return false;
   }
 
@@ skipping 139 matching lines @@
     assert(node is Continuation || node is LetPrim || node is Parameter ||
            node is Branch);
   }
 
   bool operator==(_ReductionTask that) {
     return (that.kind == this.kind && that.node == this.node);
   }
 
   String toString() => "$kind: $node";
 }