dart2js cps: Retain refinement nodes and update refinements after GVN.

pkg/compiler/lib/src/cps_ir/gvn.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.gvn;
 
 import 'cps_ir_nodes.dart';
 import '../universe/side_effects.dart';
 import '../elements/elements.dart';
 import 'optimizers.dart' show Pass;
@@ skipping 77 matching lines @@
   void rewrite(FunctionDefinition node) {
     gvnVectorBuilder = new GvnVectorBuilder(gvnFor, backend);
     loopHierarchy = new LoopHierarchy(node);
     loopEffects =
         new LoopSideEffects(node, world, loopHierarchy: loopHierarchy);
     visit(node);
   }
 
   // ------------------ GLOBAL VALUE NUMBERING ---------------------
 
+  /// True if [prim] can be eliminated if its value is already in scope.
+  bool canReplaceWithExistingValue(Primitive prim) {
+    // Primitives that have no side effects other than potentially throwing are
+    // known not the throw if the value is already in scope. Handling those
+    // specially is equivalent to updating refinements during GVN.
+    // GetLazyStatic cannot have side effects because the field has already
+    // been initialized.
+    // TODO(asgerf): Replace GetLazyStatic in an earlier pass so it does not
+    //   confuse the LoopSideEffects pre-analysis.
+    return prim.isSafeForElimination ||
+           prim is GetField ||
+           prim is GetLength ||
+           prim is GetIndex ||
+           prim is GetLazyStatic;
+  }
+
   @override
   Expression traverseLetPrim(LetPrim node) {
     Expression next = node.body;
     Primitive prim = node.primitive;
 
     loopHeaderFor[prim] = currentLoopHeader;
 
     if (prim is Refinement) {
       // Do not share refinements (they have no runtime or code size cost), and
       // do not put them in the GVN table because GvnVectorBuilder unfolds
@@ skipping 14 matching lines @@
       return next;
     }
 
     // Compute the GVN for this primitive.
     int gvn = gvnTable.insert(vector);
     gvnFor[prim] = gvn;
 
     // Try to reuse a previously computed value with the same GVN.
     Primitive existing = environment[gvn];
     if (existing != null &&
-        (prim.isSafeForElimination || prim is GetLazyStatic) &&
+        canReplaceWithExistingValue(prim) &&
         !isTrivialPrimitive(prim)) {
       if (prim is Interceptor) {
         Interceptor interceptor = existing;
         interceptor.interceptedClasses.addAll(prim.interceptedClasses);
         interceptor.flags |= prim.flags;
       }
       prim..replaceUsesWith(existing)..destroy();
       node.remove();
       return next;
     }
@@ skipping 554 matching lines @@
 
   @override
   processReference(Reference ref) {
     callback(ref);
   }
 
   static void forEach(Primitive node, ReferenceCallback callback) {
     new InputVisitor(callback).visit(node);
   }
 }