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,
     ConstructedConstant,
     MessageKind,
     StringConstant,
     invariant;
 
 import 'dart_backend/dart_backend.dart' show
     DartBackend;
 
 import 'elements/elements.dart' show
     Element,
     ClassElement,
     ElementKind,
     Elements,
     FunctionElement,
     LibraryElement,
     MetadataAnnotation,
     ScopeContainerElement,
     PrefixElement,
-    ClosureContainer;
+    ClosureContainer,
+    STATE_DONE;
 
 import 'util/util.dart' show
     Link;
 
 import 'util/setlet.dart' show
     Setlet;
 
 import 'tree/tree.dart' show
     LibraryTag,
     Node,
@@ skipping 256 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) {
+    // TODO(sigurdm): How is metadata on a patch-class handled?
     element = element.implementation;

[Johnni Winther, 2014/04/01 13:20:00]

Remove this line.

[sigurdm, 2014/04/01 13:57:44]

Done.

     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.isClass() &&

[karlklose, 2014/04/01 13:48:18]

Consider using an is-test here, as you expect a subtype of ClassElement anyway.

[sigurdm, 2014/04/01 13:57:44]

Done.

+                (element as ClassElement).resolutionState != STATE_DONE) {

[Johnni Winther, 2014/04/01 13:20:00]

Use `!isResolved` instead of `resolutionState != STATE_DONE`.

[sigurdm, 2014/04/01 13:57:44]

Done.

+              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);
     }
   }
 }