dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/redundant_join.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 dart2js.cps_ir.redundant_join_elimination;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Eliminates redundant join points.
@@ skipping 62 matching lines @@
     if (!branchCont.hasMultipleUses) return;
 
     // It might be beneficial to rewrite calls to recursive continuations,
     // but we currently do not support this.
     if (branchCont.isRecursive) return;
 
     // Check that the branching condition is a parameter on the
     // enclosing continuation.
     // Note: Do not use the parent pointer for this check, because parameters
     // are temporarily shared between different continuations during this pass.
-    Primitive condition = branch.condition.definition;
+    Primitive condition = branch.condition;
     int parameterIndex = branchCont.parameters.indexOf(condition);
     if (parameterIndex == -1) return;
 
     // Check that all callers hit a fixed branch, and count the number
     // of times each branch is hit.
     // We know all callers are InvokeContinuations because they are the only
     // valid uses of a multi-use continuation.
     int trueHits = 0, falseHits = 0;
     InvokeContinuation trueCall, falseCall;
     for (Reference ref = branchCont.firstRef; ref != null; ref = ref.next) {
       InvokeContinuation invoke = ref.parent;
-      Primitive argument = invoke.arguments[parameterIndex].definition;
+      Primitive argument = invoke.argument(parameterIndex);
       if (argument is! Constant) return; // Branching condition is unknown.
       Constant constant = argument;
       if (isTruthyConstant(constant.value, strict: branch.isStrictCheck)) {
         ++trueHits;
         trueCall = invoke;
       } else {
         ++falseHits;
         falseCall = invoke;
       }
     }
@@ skipping 26 matching lines @@
     // continuations. [AlphaRenamer] will clean up at the end of this pass.
     LetCont outerLetCont = branchCont.parent;
     while (branchCont.body is LetCont) {
       LetCont innerLetCont = branchCont.body;
       for (Continuation innerCont in innerLetCont.continuations) {
         innerCont.parameters.addAll(branchCont.parameters);
         for (Reference ref = innerCont.firstRef; ref != null; ref = ref.next) {
           Expression use = ref.parent;
           if (use is InvokeContinuation) {
             for (Parameter param in branchCont.parameters) {
-              use.arguments.add(new Reference<Primitive>(param)..parent = use);
+              use.argumentRefs.add(new Reference<Primitive>(param)..parent = use);

[Siggi Cherem (dart-lang), 2016/02/29 18:00:00]

80 col

[asgerf, 2016/03/01 12:06:59]

Done.

             }
           } else {
             // The branch will be eliminated, so don't worry about updating it.
             assert(use == branch);
           }
         }
       }
       innerLetCont.remove();
       innerLetCont.insertAbove(outerLetCont);
     }
 
     assert(branchCont.body == branch);
 
-    Continuation trueCont = branch.trueContinuation.definition;
-    Continuation falseCont = branch.falseContinuation.definition;
+    Continuation trueCont = branch.trueContinuation;
+    Continuation falseCont = branch.falseContinuation;
 
     assert(branchCont != trueCont);
     assert(branchCont != falseCont);
 
     // Rewrite every invocation of branchCont to call either the true or false
     // branch directly. Since these were lifted out above branchCont, they are
     // now in scope.
     // Since trueCont and falseCont were branch targets, they originally
     // had no parameters, and so after the lifting, their parameters are
     // exactly the same as those accepted by branchCont.
     while (branchCont.firstRef != null) {
       Reference reference = branchCont.firstRef;
       InvokeContinuation invoke = branchCont.firstRef.parent;
-      Constant condition = invoke.arguments[parameterIndex].definition;
+      Constant condition = invoke.argument(parameterIndex);
       if (isTruthyConstant(condition.value, strict: branch.isStrictCheck)) {
-        invoke.continuation.changeTo(trueCont);
+        invoke.continuationRef.changeTo(trueCont);
       } else {
-        invoke.continuation.changeTo(falseCont);
+        invoke.continuationRef.changeTo(falseCont);
       }
       assert(branchCont.firstRef != reference);
     }
 
     // Remove the now-unused branchCont continuation.
     assert(branchCont.hasNoUses);
-    branch.trueContinuation.unlink();
-    branch.falseContinuation.unlink();
+    branch.trueContinuationRef.unlink();
+    branch.falseContinuationRef.unlink();
     outerLetCont.continuations.remove(branchCont);
     if (outerLetCont.continuations.isEmpty) {
       outerLetCont.remove();
     }
 
     // We may have created new redundant join points in the two branches.
     enqueueContinuation(trueCont);
     enqueueContinuation(falseCont);
   }
 
@@ skipping 57 matching lines @@
     });
   }
 
   processReference(Reference ref) {
     Parameter target = renaming[ref.definition];
     if (target != null) {
       ref.changeTo(target);
     }
   }
 }