Allow updates and include statics when computing deferred elements.

sdk/lib/_internal/compiler/implementation/deferred_load.dart

 // Copyright (c) 2014, 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 deferred_load;
 
 import 'dart2jslib.dart' show
     Backend,
     Compiler,
     CompilerTask,
@@ skipping 276 matching lines @@
     return library.getImportsFor(element);
   }
 
   /// Finds all elements and constants that [element] depends directly on.
   /// (not the transitive closure.)
   ///
   /// Adds the results to [elements] and [constants].
   void _collectAllElementsAndConstantsResolvedFrom(
       Element element,
       Set<Element> elements,
-      Set<Constant> constants) {
+      Set<Constant> constants,
+      isMirrorUsage) {
 
     /// Recursively add the constant and its dependencies to [constants].
     void addConstants(Constant constant) {
       if (constants.contains(constant)) return;
       constants.add(constant);
       if (constant is ConstructedConstant) {
         elements.add(constant.type.element);
       }
       constant.getDependencies().forEach(addConstants);
     }
@@ skipping 29 matching lines @@
 
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
       Constant constant = backend.constants.getConstantForMetadata(metadata);
       if (constant != null) {
         addConstants(constant);
       }
     }
     if (element.isClass) {
       // If we see a class, add everything its live instance members refer
-      // to.  Static members are not relevant.
+      // to.  Static members are not relevant, unless we are processing
+      // extra dependencies due to mirrors.
       void addLiveInstanceMember(Element element) {
         if (!compiler.enqueuer.resolution.isLive(element)) return;
-        if (!element.isInstanceMember) return;
+        if (!isMirrorUsage && !element.isInstanceMember) return;
         collectDependencies(element.implementation);
       }
       ClassElement cls = element.declaration;
       cls.forEachLocalMember(addLiveInstanceMember);
       if (cls.implementation != cls) {
         // TODO(ahe): Why doesn't ClassElement.forEachLocalMember do this?
         cls.implementation.forEachLocalMember(addLiveInstanceMember);
       }
       for (var type in cls.implementation.allSupertypes) {
         elements.add(type.element.implementation);
       }
       elements.add(cls.implementation);
     } else if (Elements.isStaticOrTopLevel(element) ||
                element.isConstructor) {
       collectDependencies(element);
     }
     if (element.isGenerativeConstructor) {
       // When instantiating a class, we record a reference to the
       // constructor, not the class itself.  We must add all the
       // instance members of the constructor's class.
       ClassElement implementation =
           element.enclosingClass.implementation;
       _collectAllElementsAndConstantsResolvedFrom(
-          implementation, elements, constants);
+          implementation, elements, constants, isMirrorUsage);
     }
 
     // Other elements, in particular instance members, are ignored as
     // they are processed as part of the class.
   }
 
   /// Returns the transitive closure of all libraries that are imported
   /// from root without DeferredLibrary annotations.
   Set<LibraryElement> _nonDeferredReachableLibraries(LibraryElement root) {
     Set<LibraryElement> result = new Set<LibraryElement>();
@@ skipping 22 matching lines @@
       }
     }
     traverseLibrary(root);
     result.add(compiler.coreLibrary);
     return result;
   }
 
   /// Recursively traverses the graph of dependencies from [element], mapping
   /// deferred imports to each dependency it needs in the sets
   /// [_importedDeferredBy] and [_constantsDeferredBy].
-  void _mapDependencies(Element element, Import import) {
+  void _mapDependencies(Element element, Import import,
+                        {isMirrorUsage: false}) {
     Set<Element> elements = _importedDeferredBy.putIfAbsent(import,
         () => new Set<Element>());
     Set<Constant> constants = _constantsDeferredBy.putIfAbsent(import,
         () => new Set<Constant>());
 
-    if (elements.contains(element)) return;
+    // Only process elements once, unless we are doing dependencies due to
+    // mirrors, which are added in additional traversals.
+    if (!isMirrorUsage && elements.contains(element)) return;
     // Anything used directly by main will be loaded from the start
     // We do not need to traverse it again.
     if (import != _fakeMainImport && _mainElements.contains(element)) return;
 
     // Here we modify [_importedDeferredBy].
     elements.add(element);
 
     Set<Element> dependentElements = new Set<Element>();
 
     // This call can modify [_importedDeferredBy] and [_constantsDeferredBy].
     _collectAllElementsAndConstantsResolvedFrom(
-        element, dependentElements, constants);
+        element, dependentElements, constants, isMirrorUsage);
 
     LibraryElement library = element.library;
     for (Element dependency in dependentElements) {
       if (_isExplicitlyDeferred(dependency, library)) {
         for (Import deferredImport in _getImports(dependency, library)) {
           _mapDependencies(dependency, deferredImport);
         };
       } else {
         _mapDependencies(dependency, import);
       }
     }
   }
 
   /// Adds extra dependencies coming from mirror usage.
   ///
   /// The elements are added with [_mapDependencies].
   void _addMirrorElements() {
     void mapDependenciesIfResolved(Element element, Import deferredImport) {
       // If an element is the target of a MirrorsUsed annotation but never used
       // It will not be resolved, and we should not call isNeededForReflection.
       // TODO(sigurdm): Unresolved elements should just answer false when
       // asked isNeededForReflection. Instead an internal error is triggered.
       // So we have to filter them out here.
       if (element is AnalyzableElementX && !element.hasTreeElements) return;
       if (compiler.backend.isNeededForReflection(element)) {
-        _mapDependencies(element, deferredImport);
+        _mapDependencies(element, deferredImport, isMirrorUsage: true);
       }
     }
 
     // For each deferred import we analyze all elements reachable from the
     // imported library through non-deferred imports.
     handleLibrary(LibraryElement library, Import deferredImport) {
       library.implementation.forEachLocalMember((Element element) {
         mapDependenciesIfResolved(element, deferredImport);
       });
 
@@ skipping 311 matching lines @@
     Element maybePrefix = elements[identifier];
     if (maybePrefix != null && maybePrefix.isPrefix) {
       PrefixElement prefixElement = maybePrefix;
       if (prefixElement.isDeferred) {
         return prefixElement;
       }
     }
     return null;
   }
 }