dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/bounds_checker.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.bounds_checker;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart' show Pass;
 import 'octagon.dart';
 import '../constants/values.dart';
@@ skipping 251 matching lines @@
 
   bool isDefinitelyGreaterThanOrEqualToConstant(SignedVariable v1, int value) {
     // v1 >= value   <==>   -v1 - v1 <= -2 * value
     return testConstraint(v1.negated, v1.negated, -2 * value);
   }
 
   // ------------- TAIL EXPRESSIONS -----------------
 
   @override
   void visitBranch(Branch node) {
-    Primitive condition = node.condition.definition;
-    Continuation trueCont = node.trueContinuation.definition;
-    Continuation falseCont = node.falseContinuation.definition;
+    Primitive condition = node.condition;
+    Continuation trueCont = node.trueContinuation;
+    Continuation falseCont = node.falseContinuation;
     effectNumberAt[trueCont] = currentEffectNumber;
     effectNumberAt[falseCont] = currentEffectNumber;
     pushAction(() {
       // If the branching condition is known statically, either or both of the
       // branch continuations will be replaced by Unreachable. Clean up the
       // branch afterwards.
       if (trueCont.body is Unreachable && falseCont.body is Unreachable) {
         destroyAndReplace(node, new Unreachable());
       } else if (trueCont.body is Unreachable) {
         destroyAndReplace(
             node, new InvokeContinuation(falseCont, <Parameter>[]));
       } else if (falseCont.body is Unreachable) {
         destroyAndReplace(
             node, new InvokeContinuation(trueCont, <Parameter>[]));
       }
     });
     void pushTrue(makeConstraint()) {
       pushAction(() {
         makeConstraint();
         push(trueCont);
       });
     }
     void pushFalse(makeConstraint()) {
       pushAction(() {
         makeConstraint();
         push(falseCont);
       });
     }
     if (condition is ApplyBuiltinOperator &&
-        condition.arguments.length == 2 &&
-        isInt(condition.arguments[0].definition) &&
-        isInt(condition.arguments[1].definition)) {
-      SignedVariable v1 = getValue(condition.arguments[0].definition);
-      SignedVariable v2 = getValue(condition.arguments[1].definition);
+        condition.argumentRefs.length == 2 &&
+        isInt(condition.argument(0)) &&
+        isInt(condition.argument(1))) {
+      SignedVariable v1 = getValue(condition.argument(0));
+      SignedVariable v2 = getValue(condition.argument(1));
       switch (condition.operator) {
         case BuiltinOperator.NumLe:
           pushTrue(() => makeLessThanOrEqual(v1, v2));
           pushFalse(() => makeGreaterThan(v1, v2));
           return;
         case BuiltinOperator.NumLt:
           pushTrue(() => makeLessThan(v1, v2));
           pushFalse(() => makeGreaterThanOrEqual(v1, v2));
           return;
         case BuiltinOperator.NumGe:
@@ skipping 26 matching lines @@
     //               constraints that reference it.
     if (node.value.isInt) {
       IntConstantValue constant = node.value;
       makeConstant(getValue(node), constant.primitiveValue);
     }
   }
 
   @override
   void visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     if (!isInt(node)) return;
-    if (node.arguments.length == 1) {
+    if (node.argumentRefs.length == 1) {
       applyUnaryOperator(node);
-    } else if (node.arguments.length == 2) {
+    } else if (node.argumentRefs.length == 2) {
       applyBinaryOperator(node);
     }
   }
 
   void applyBinaryOperator(ApplyBuiltinOperator node) {
-    Primitive left = node.arguments[0].definition;
-    Primitive right = node.arguments[1].definition;
+    Primitive left = node.argument(0);
+    Primitive right = node.argument(1);
     if (!isInt(left) || !isInt(right)) {
       return;
     }
     SignedVariable leftVar = getValue(left);
     SignedVariable rightVar = getValue(right);
     SignedVariable result = getValue(node);
     switch (node.operator) {
       case BuiltinOperator.NumAdd:
         int leftConst = getIntConstant(left);
         if (leftConst != null) {
@@ skipping 80 matching lines @@
         if (isUInt32(right)) {
           makeLessThanOrEqual(result, rightVar);
         }
         break;
 
       default:
     }
   }
 
   void applyUnaryOperator(ApplyBuiltinOperator node) {
-    Primitive argument = node.arguments[0].definition;
+    Primitive argument = node.argument(0);
     if (!isInt(argument)) return;
     if (node.operator == BuiltinOperator.NumNegate) {
       valueOf[node] = getValue(argument).negated;
     }
   }
 
   int getIntConstant(Primitive prim) {
     if (prim is Constant && prim.value.isInt) {
       IntConstantValue constant = prim.value;
       return constant.primitiveValue;
     }
     return null;
   }
 
   @override
   void visitRefinement(Refinement node) {
     // In general we should get the container length of the refined type and
     // add a constraint if we know the length after the refinement.
     // However, our current type system removes container information when a
     // type becomes part of a union, so this cannot happen.
   }
 
   @override
   void visitGetLength(GetLength node) {
-    valueOf[node] = getLength(node.object.definition, currentEffectNumber);
+    valueOf[node] = getLength(node.object, currentEffectNumber);
   }
 
   @override
   void visitBoundsCheck(BoundsCheck node) {
     if (node.checks == BoundsCheck.NONE) return;
-    assert(node.index != null); // Because there is at least one check.
-    SignedVariable length = node.length == null
+    assert(node.indexRef != null); // Because there is at least one check.
+    SignedVariable length = node.lengthRef == null
         ? null
-        : getValue(node.length.definition);
-    SignedVariable index = getValue(node.index.definition);
+        : getValue(node.length);
+    SignedVariable index = getValue(node.index);
     if (node.hasUpperBoundCheck) {
       if (isDefinitelyLessThan(index, length)) {
         node.checks &= ~BoundsCheck.UPPER_BOUND;
       } else {
         makeLessThan(index, length);
       }
     }
     if (node.hasLowerBoundCheck) {
       if (isDefinitelyGreaterThanOrEqualToConstant(index, 0)) {
         node.checks &= ~BoundsCheck.LOWER_BOUND;
       } else {
         makeGreaterThanOrEqualToConstant(index, 0);
       }
     }
     if (node.hasEmptinessCheck) {
       if (isDefinitelyGreaterThanOrEqualToConstant(length, 1)) {
         node.checks &= ~BoundsCheck.EMPTINESS;
       } else {
         makeGreaterThanOrEqualToConstant(length, 1);
       }
     }
-    if (!node.lengthUsedInCheck && node.length != null) {
-      node..length.unlink()..length = null;
+    if (!node.lengthUsedInCheck && node.lengthRef != null) {
+      node..lengthRef.unlink()..lengthRef = null;
     }
     if (node.checks == BoundsCheck.NONE) {
       // We can't remove the bounds check node because it may still be used to
       // restrict code motion.  But the index is no longer needed.
-      node..index.unlink()..index = null;
+      node..indexRef.unlink()..indexRef = null;
     }
   }
 
   void analyzeLoopEntry(InvokeContinuation node) {
     foundLoop = true;
-    Continuation cont = node.continuation.definition;
+    Continuation cont = node.continuation;
     if (isStrongLoopPass) {
-      for (int i = 0; i < node.arguments.length; ++i) {
+      for (int i = 0; i < node.argumentRefs.length; ++i) {
         Parameter param = cont.parameters[i];
         if (!isInt(param)) continue;
-        Primitive initialValue = node.arguments[i].definition;
+        Primitive initialValue = node.argument(i);
         SignedVariable initialVariable = getValue(initialValue);
         Monotonicity mono = monotonicity[param];
         if (mono == null) {
           // Value never changes. This is extremely uncommon.
           param.replaceUsesWith(initialValue);
         } else if (mono == Monotonicity.Increasing) {
           makeGreaterThanOrEqual(getValue(param), initialVariable);
         } else if (mono == Monotonicity.Decreasing) {
           makeLessThanOrEqual(getValue(param), initialVariable);
         }
       }
     }
     if (loopEffects.changesIndexableLength(cont)) {
       currentEffectNumber = effectNumberAt[cont] = makeNewEffect();
     }
     push(cont);
   }
 
   void analyzeLoopContinue(InvokeContinuation node) {
-    Continuation cont = node.continuation.definition;
+    Continuation cont = node.continuation;
 
     // During the strong loop phase, there is no need to compute monotonicity,
     // and we already put bounds on the loop variables when we went into the
     // loop.
     if (isStrongLoopPass) return;
 
     // For each loop parameter, try to prove that the new value is definitely
     // less/greater than its old value. When we fail to prove this, update the
     // monotonicity flag accordingly.
-    for (int i = 0; i < node.arguments.length; ++i) {
+    for (int i = 0; i < node.argumentRefs.length; ++i) {
       Parameter param = cont.parameters[i];
       if (!isInt(param)) continue;
-      SignedVariable arg = getValue(node.arguments[i].definition);
+      SignedVariable arg = getValue(node.argument(i));
       SignedVariable paramVar = getValue(param);
       if (!isDefinitelyLessThanOrEqualTo(arg, paramVar)) {
         // We couldn't prove that the value does not increase, so assume
         // henceforth that it might be increasing.
         markMonotonicity(cont.parameters[i], Monotonicity.Increasing);
       }
       if (!isDefinitelyGreaterThanOrEqualTo(arg, paramVar)) {
         // We couldn't prove that the value does not decrease, so assume
         // henceforth that it might be decreasing.
         markMonotonicity(cont.parameters[i], Monotonicity.Decreasing);
       }
     }
   }
 
   void markMonotonicity(Parameter param, Monotonicity mono) {
     Monotonicity current = monotonicity[param];
     if (current == null) {
       monotonicity[param] = mono;
     } else if (current != mono) {
       monotonicity[param] = Monotonicity.NotMonotone;
     }
   }
 
   @override
   void visitInvokeContinuation(InvokeContinuation node) {
-    Continuation cont = node.continuation.definition;
+    Continuation cont = node.continuation;
     if (node.isRecursive) {
       analyzeLoopContinue(node);
     } else if (cont.isRecursive) {
       analyzeLoopEntry(node);
     } else {
       int effect = effectNumberAt[cont];
       if (effect == null) {
         effectNumberAt[cont] = currentEffectNumber;
       } else if (effect != currentEffectNumber && effect != NEW_EFFECT) {
         effectNumberAt[cont] = NEW_EFFECT;
@@ skipping 25 matching lines @@
       TypeMask successType =
           types.receiverTypeFor(node.selector, node.dartReceiver.type);
       if (types.isDefinitelyIndexable(successType)) {
         valueOf[node] = getLength(node.dartReceiver, currentEffectNumber);
       }
     }
   }
 
   @override
   void visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
-    Primitive receiver = node.receiver.definition;
+    Primitive receiver = node.receiver;
     int effectBefore = currentEffectNumber;
     currentEffectNumber = makeNewEffect();
     int effectAfter = currentEffectNumber;
     SignedVariable lengthBefore = getLength(receiver, effectBefore);
     SignedVariable lengthAfter = getLength(receiver, effectAfter);
     switch (node.method) {
       case BuiltinMethod.Push:
         // after = before + count
-        int count = node.arguments.length;
+        int count = node.argumentRefs.length;
         makeExactSum(lengthAfter, lengthBefore, count);
         break;
 
       case BuiltinMethod.Pop:
         // after = before - 1
         makeExactSum(lengthAfter, lengthBefore, -1);
         break;
 
       case BuiltinMethod.SetLength:
-        makeEqual(lengthAfter, getValue(node.arguments[0].definition));
+        makeEqual(lengthAfter, getValue(node.argument(0)));
         break;
     }
   }
 
   @override
   void visitLiteralList(LiteralList node) {
-    makeConstant(getLength(node, currentEffectNumber), node.values.length);
+    makeConstant(getLength(node, currentEffectNumber), node.valueRefs.length);
   }
 
   // ---------------- INTERIOR EXPRESSIONS --------------------
 
   @override
   Expression traverseContinuation(Continuation cont) {
     if (octagon.isUnsolvable) {
       destroyAndReplace(cont.body, new Unreachable());
     } else {
       int effect = effectNumberAt[cont];
@@ skipping 18 matching lines @@
     }
     return node.body;
   }
 }
 
 /// Lattice representing the known (weak) monotonicity of a loop variable.
 ///
 /// The lattice bottom is represented by `null` and represents the case where
 /// the loop variable never changes value during the loop.
 enum Monotonicity { NotMonotone, Increasing, Decreasing, }