dart2js: collect static-non-final fields in the task.

pkg/compiler/lib/src/js_emitter/code_emitter_task.dart

 // Copyright (c) 2012, 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.
 
 part of dart2js.js_emitter;
 
 const USE_NEW_EMITTER = const bool.fromEnvironment("dart2js.use.new.emitter");
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   // TODO(floitsch): the code-emitter task should not need a namer.
   final Namer namer;
   final TypeTestRegistry typeTestRegistry;
   NativeEmitter nativeEmitter;
   OldEmitter oldEmitter;
   Emitter emitter;
 
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final Map<OutputUnit, List<ClassElement>> outputClassLists =
       new Map<OutputUnit, List<ClassElement>>();
   final Map<OutputUnit, List<ConstantValue>> outputConstantLists =
       new Map<OutputUnit, List<ConstantValue>>();
   final Map<OutputUnit, List<Element>> outputStaticLists =
       new Map<OutputUnit, List<Element>>();
+  final Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists =
+      new Map<OutputUnit, List<VariableElement>>();
   final Map<OutputUnit, Set<LibraryElement>> outputLibraryLists =
       new Map<OutputUnit, Set<LibraryElement>>();
 
   /// True, if the output contains a constant list.
   ///
   /// This flag is updated in [computeNeededConstants].
   bool outputContainsConstantList = false;
 
   final List<ClassElement> nativeClasses = <ClassElement>[];
 
@@ skipping 313 matching lines @@
   }
 
   void computeNeededStatics() {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember && !element.isField;
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
 
     for (Element element in Elements.sortedByPosition(elements)) {
-      outputStaticLists.putIfAbsent(
+      List<Element> list = outputStaticLists.putIfAbsent(
           compiler.deferredLoadTask.outputUnitForElement(element),
-          () => new List<Element>())
-          .add(element);
+          () => new List<Element>());
+      list.add(element);
     }
   }
 
+  void computeNeededStaticNonFinalFields() {
+    JavaScriptConstantCompiler handler = backend.constants;
+    Iterable<VariableElement> staticNonFinalFields =
+        handler.getStaticNonFinalFieldsForEmission();
+    for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
+      List<VariableElement> list = outputStaticNonFinalFieldLists.putIfAbsent(
+            compiler.deferredLoadTask.outputUnitForElement(element),
+            () => new List<VariableElement>());
+      list.add(element);
+    }
+  }
+
   void computeNeededLibraries() {
     void addSurroundingLibraryToSet(Element element) {
       OutputUnit unit = compiler.deferredLoadTask.outputUnitForElement(element);
       LibraryElement library = element.library;
       outputLibraryLists.putIfAbsent(unit, () => new Set<LibraryElement>())
           .add(library);
     }
 
     backend.generatedCode.keys.forEach(addSurroundingLibraryToSet);
     neededClasses.forEach(addSurroundingLibraryToSet);
   }
 
   void computeAllNeededEntities() {
     // Compute the required type checks to know which classes need a
     // 'is$' method.
     typeTestRegistry.computeRequiredTypeChecks();
 
     computeNeededDeclarations();
     computeNeededConstants();
     computeNeededStatics();
+    computeNeededStaticNonFinalFields();
     computeNeededLibraries();
   }
 
   int assembleProgram() {
     return measure(() {
       emitter.invalidateCaches();
 
       computeAllNeededEntities();
 
       Program program;
@@ skipping 41 matching lines @@
   jsAst.Expression interceptorClassAccess(ClassElement e);
 
   /// Returns the JS expression representing the type [e].
   jsAst.Expression typeAccess(Element e);
 
   int compareConstants(ConstantValue a, ConstantValue b);
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant);
 
   void invalidateCaches();
 }