dart2js cps: Replace GetLazyStatic with GetStatic.

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 86 matching lines @@
 
   // ------------------ 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
       // refinements by itself.
       return next;
     }
 
+    // Update effect numbers due to side effects from a static initializer.
+    // GetLazyStatic is GVN'ed like a GetStatic, but the effects of the static
+    // initializer occur before reading the field.
+    if (prim is GetLazyStatic) {
+      visit(prim);
+    }
+
     // Compute the GVN vector for this computation.
     List vector = gvnVectorBuilder.make(prim, effectNumbers);
 
     // Update effect numbers due to side effects.
     // Do this after computing the GVN vector so the primitive's GVN is not
-    // influenced by its own side effects.
-    visit(prim);
+    // influenced by its own side effects, except in the case of GetLazyStatic.
+    if (prim is! GetLazyStatic) {
+      visit(prim);
+    }
 
     if (vector == null) {
       // The primitive is not GVN'able. Move on.
       return next;
     }
 
     // Compute the GVN for this primitive.
     int gvn = gvnTable.insert(vector);
     gvnFor[prim] = gvn;
 
@@ skipping 521 matching lines @@
       vector = [GvnCode.GET_FIELD, node.field];
     } else {
       vector = [GvnCode.GET_FIELD, node.field, effectNumbers.instanceField];
     }
   }
 
   processGetIndex(GetIndex node) {
     vector = [GvnCode.GET_INDEX, effectNumbers.indexableContent];
   }
 
-  processGetStatic(GetStatic node) {
+  visitGetStatic(GetStatic node) {
     if (isImmutable(node.element)) {
       vector = [GvnCode.GET_STATIC, node.element];
     } else {
       vector = [GvnCode.GET_STATIC, node.element, effectNumbers.staticField];
     }
+    // Suppress visit to witness argument.
   }
 
   processGetLazyStatic(GetLazyStatic node) {
     if (isImmutable(node.element)) {
       vector = [GvnCode.GET_STATIC, node.element];
     } else {
       vector = [GvnCode.GET_STATIC, node.element, effectNumbers.staticField];
     }
   }
 
@@ skipping 41 matching lines @@
 
   @override
   processReference(Reference ref) {
     callback(ref);
   }
 
   static void forEach(Primitive node, ReferenceCallback callback) {
     new InputVisitor(callback).visit(node);
   }
 }