Improve the mirror support for deferred loading.

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
     Compiler,
     CompilerTask,
     Constant,
@@ skipping 285 matching lines @@
     elementDependencies.addAll(elements.otherDependencies);
   }
 
   /// 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) {
-    element = element.implementation;
+    // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
       if (metadata.value != null) {
         constants.add(metadata.value);
         elements.add(metadata.value.computeType(compiler).element);
       }
     }
     if (element.isClass()) {
       // If we see a class, add everything its instance members refer
       // to.  Static members are not relevant.
       ClassElement cls = element.declaration;
@@ skipping 118 matching lines @@
 
         if (mirrorTask.librariesWithUsage.contains(library)) {
 
           Map<LibraryElement, List<MirrorUsage>> mirrorsResult =
               mirrorTask.analyzer.collectMirrorsUsedAnnotation();
 
           // If there is a MirrorsUsed annotation we add only the needed
           // things to the output units for the library.
           List<MirrorUsage> mirrorUsages = mirrorsResult[library];
           if (mirrorUsages == null) continue;
+
+          void mapDependenciesIfResolved(Element element) {
+            // If there is a target for this class, but no use of mirrors the
+            // class will not be resolved. We just skip it.
+            if (element is ClassElement &&
+                !(element as ClassElement).isResolved) {
+              return;
+            }
+            _mapDependencies(element, deferredImport);
+          }
+
           for (MirrorUsage usage in mirrorUsages) {
             if (usage.targets != null) {
               for (Element dependency in usage.targets) {
-                _mapDependencies(dependency, deferredImport);
+                if (dependency.isLibrary()) {
+                  LibraryElement library = dependency;
+                  library.forEachLocalMember(mapDependenciesIfResolved);
+                } else {
+                  mapDependenciesIfResolved(dependency);
+                }
               }
             }
             if (usage.metaTargets != null) {
               for (Element dependency in usage.metaTargets) {
                 _mapDependencies(dependency, deferredImport);
               }
             }
           }
         } else {
           // If there is no MirrorsUsed annotation we add _everything_ to
@@ skipping 18 matching lines @@
           //   deferred libraries at the same time.
           bool usesMirrors = false;
           for (LibraryTag tag in library.tags) {
             if (tag is! Import) continue;
             if (library.getLibraryFromTag(tag) == compiler.mirrorsLibrary) {
               usesMirrors = true;
               break;
             }
           }
           if (usesMirrors) {
-            for (Link link in compiler.enqueuer.allElementsByName.values) {
-              for (Element dependency in link) {
-                _mapDependencies(dependency, deferredImport);
-              }
+            // Add all resolved elements to the output unit.
+            for (Element element in
+                compiler.enqueuer.resolution.resolvedElements.keys) {
+              _mapDependencies(element, deferredImport);
+            }
+            for (Element element in
+                compiler.mirrorDependencies.otherDependencies) {
+              _mapDependencies(element, deferredImport);
             }
           }
         }
       }
     }
   }
 
   /// Goes through [allConstants] and adjusts their outputUnits.
   void _adjustConstantsOutputUnit(Set<Constant> allConstants) {
     // A constant has three dependencies:
@@ skipping 247 matching lines @@
     }
     if (splitProgram && compiler.backend is DartBackend) {
       // TODO(sigurdm): Implement deferred loading for dart2dart.
       splitProgram = false;
       compiler.reportInfo(
           lastDeferred,
           MessageKind.DEFERRED_LIBRARY_DART_2_DART);
     }
   }
 }