Revert "dart2js cps: Refactor tracking of side effects."

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';
 import 'cps_fragment.dart';
 import 'type_mask_system.dart';
 import '../types/types.dart';
 import '../world.dart';
 import '../elements/elements.dart';
 import 'loop_effects.dart';
-import 'effects.dart';
 
 /// Eliminates bounds checks when they can be proven safe.
 ///
 /// In general, this pass will try to eliminate any branch with arithmetic
 /// in the condition, i.e. `x < y`, `x <= y`, `x == y` etc.
 ///
 /// The analysis uses an [Octagon] abstract domain. Unlike traditional octagon
 /// analyzers, we do not use a closed matrix representation, but just maintain
 /// a bucket of constraints.  Constraints can therefore be added and removed
 /// on-the-fly without significant overhead.
@@ skipping 514 matching lines @@
         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)) {
+    if (loopEffects.loopChangesLength(cont)) {
       currentEffectNumber = effectNumberAt[cont] = makeNewEffect();
     }
     push(cont);
   }
 
   void analyzeLoopContinue(InvokeContinuation node) {
     Continuation cont = node.continuation.definition;
 
     // 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
@@ skipping 44 matching lines @@
       } else if (effect != currentEffectNumber && effect != NEW_EFFECT) {
         effectNumberAt[cont] = NEW_EFFECT;
       }
       // TODO(asgerf): Compute join for parameters to increase precision?
     }
   }
 
   // ---------------- PRIMITIVES --------------------
 
   @override
-  Expression traverseLetPrim(LetPrim node) {
-    visit(node.primitive);
-    // visitApplyBuiltinMethod updates the effect number.
-    if (node.primitive is! ApplyBuiltinMethod) {
-      if (node.primitive.effects & Effects.changesIndexableLength != 0) {
-        currentEffectNumber = makeNewEffect();
-      }
-    }
-    return node.body;
-  }
-
-  @override
   void visitInvokeMethod(InvokeMethod node) {
     if (node.selector.isGetter && node.selector.name == 'length') {
       // If the receiver type is not known to be indexable, the length call
       // was not rewritten to GetLength.  But if we can prove that the call only
       // succeeds for indexables, we can trust that it returns the length.
       TypeMask successType =
           types.receiverTypeFor(node.selector, node.dartReceiver.type);
       if (types.isDefinitelyIndexable(successType)) {
         valueOf[node] = getLength(node.dartReceiver, currentEffectNumber);
       }
     }
+    // TODO(asgerf): What we really need is a "changes length" side effect flag.
+    if (world
+        .getSideEffectsOfSelector(node.selector, node.mask)
+        .changesIndex()) {
+      currentEffectNumber = makeNewEffect();
+    }
   }
 
   @override
+  void visitInvokeStatic(InvokeStatic node) {
+    if (world.getSideEffectsOfElement(node.target).changesIndex()) {
+      currentEffectNumber = makeNewEffect();
+    }
+  }
+
+  @override
+  void visitInvokeMethodDirectly(InvokeMethodDirectly node) {
+    FunctionElement target = node.target;
+    if (target is ConstructorBodyElement) {
+      ConstructorBodyElement body = target;
+      target = body.constructor;
+    }
+    if (world.getSideEffectsOfElement(target).changesIndex()) {
+      currentEffectNumber = makeNewEffect();
+    }
+  }
+
+  @override
+  void visitInvokeConstructor(InvokeConstructor node) {
+    if (world.getSideEffectsOfElement(node.target).changesIndex()) {
+      currentEffectNumber = makeNewEffect();
+    }
+  }
+
+  @override
+  void visitTypeCast(TypeCast node) {
+  }
+
+  @override
+  void visitGetLazyStatic(GetLazyStatic node) {
+    // TODO(asgerf): How do we get the side effects of a lazy field initializer?
+    currentEffectNumber = makeNewEffect();
+  }
+
+  @override
+  void visitForeignCode(ForeignCode node) {
+    if (node.nativeBehavior.sideEffects.changesIndex()) {
+      currentEffectNumber = makeNewEffect();
+    }
+  }
+
+  @override
+  void visitAwait(Await node) {
+    currentEffectNumber = makeNewEffect();
+  }
+
+  @override
+  void visitYield(Yield node) {
+    currentEffectNumber = makeNewEffect();
+  }
+
+  @override
   void visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
     Primitive receiver = node.receiver.definition;
     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
@@ skipping 46 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, }