fixes #427, static fields emitted outside the scope of their class

lib/src/codegen/js_module_item_order.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.
 
 import 'dart:collection' show HashMap;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 
 import '../compiler.dart' show corelibOrder;
@@ skipping 23 matching lines @@
 
   /// The current element being loaded.
   /// We can use this to determine if we're loading top-level code or not:
   ///
   ///     _currentElements.last == _topLevelElements.last
   final _currentElements = new List<Element>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
 
+  bool _checkReferences;
+
   final ModuleItemEmitter _emitModuleItem;
 
   LibraryElement _currentLibrary;
 
   ModuleItemLoadOrder(this._emitModuleItem);
 
   bool isLoaded(Element e) => (e.library == _currentLibrary)
       ? _loaded[e] == true
       : libraryIsLoaded(e.library);
 
+  /// True if the element is currently being loaded.
+  bool _isLoading(Element e) => _currentElements.contains(e);
+
   /// Collect top-level elements and nodes we need to emit.
   void collectElements(
       LibraryElement library, Iterable<CompilationUnit> partsThenLibrary) {
     assert(_currentLibrary == null);
     _currentLibrary = library;
 
     for (var unit in partsThenLibrary) {
       for (var decl in unit.declarations) {
         _declarationNodes[decl.element] = decl;
 
-        if (decl is ClassDeclaration) {
-          for (var member in decl.members) {
-            if (member is FieldDeclaration && member.isStatic) {
-              _collectElementsForVariable(member.fields);
-            }
-          }
-        } else if (decl is TopLevelVariableDeclaration) {
+        if (decl is TopLevelVariableDeclaration) {
           _collectElementsForVariable(decl.variables);
         }
       }
     }
   }
 
   void _collectElementsForVariable(VariableDeclarationList fields) {
     for (var field in fields.variables) {
       _declarationNodes[field.element] = field;
     }
   }
 
   /// Start generating top-level code for the element [e].
   /// Subsequent [loadElement] calls will cause those elements to be generated
   /// before this one, until [finishElement] is called.
   void startTopLevel(Element e) {
     assert(isCurrentElement(e));
-    // Assume loading will succeed until proven otherwise.
-    _loaded[e] = true;
     _topLevelElements.add(e);
   }
 
   /// Finishes the top-level code for the element [e].
   void finishTopLevel(Element e) {
     var last = _topLevelElements.removeLast();
     assert(identical(e, last));
   }
 
+  /// Starts recording calls to [declareBeforeUse], until
+  /// [finishCheckingReferences] is called.
+  void startCheckingReferences() {
+    // This function should not be reentrant, and we should not current be
+    // emitting top-level code.
+    assert(_checkReferences == null);
+    assert(
+        _topLevelElements.isEmpty || !isCurrentElement(_topLevelElements.last));
+    // Assume true until proven otherwise
+    _checkReferences = true;
+  }
+
+  /// Finishes recording references, and returns `true` if all referenced
+  /// items were loaded (or if no items were referenced).
+  bool finishCheckingReferences() {
+    var result = _checkReferences;
+    _checkReferences = null;
+    return result;
+  }
+
   // Starts generating code for the declaration element [e].
   //
   // Normally this is called implicitly by [loadDeclaration] and/or
   // [loadElement]. However, for synthetic elements (like temporary variables)
   // it must be called explicitly, and paired with a call to [finishElement].
   void startDeclaration(Element e) {
     // Assume load will succeed until proven otherwise.
     _loaded[e] = true;
     _currentElements.add(e);
   }
@@ skipping 30 matching lines @@
   ///
   /// This function takes care of that, and also detects cases where reordering
   /// failed, and we need to resort to lazy loading, by marking the element as
   /// lazy. All elements need to be aware of this possibility and generate code
   /// accordingly.
   ///
   /// If we are not emitting top-level code, this does nothing, because all
   /// declarations are assumed to be available before we start execution.
   /// See [startTopLevel].
   void declareBeforeUse(Element e) {
-    if (e == null || _topLevelElements.isEmpty) return;
-    if (!isCurrentElement(_topLevelElements.last)) return;
+    if (e == null) return;
+
+    if (_checkReferences != null) {
+      _checkReferences = _checkReferences && isLoaded(e) && !_isLoading(e);
+      return;
+    }
+
+    if (_topLevelElements.isEmpty ||
+        !isCurrentElement(_topLevelElements.last)) {
+      return;
+    }
 
     // If the item is from our library, try to emit it now.
     bool loaded;
     if (e.library == _currentLibrary) {
       // Type parameters are not in scope when generating hoisted fields.
       if (e is TypeParameterElement &&
           _currentElements.last is VariableElement) {
         loaded = false;
       } else {
         var node = _declarationNodes[e];
@@ skipping 69 matching lines @@
     }
     return _libraryCycleMemo[library] = result;
   }
 
   /// Returns whether this is a library imported with 'dart:' URI.
   ///
   /// This is similar to [LibraryElement.isInSdk], but checking the URI instead
   /// of the library naming convention, because the URI is reliable.
   static bool _isDartUri(LibraryElement e) => e.source.uri.scheme == 'dart';
 }