Implement LibraryMirror.metadata.

dart/sdk/lib/_internal/compiler/implementation/compiler.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;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 625 matching lines @@
     if (dynamicClass != null) {
       // When loading the built-in libraries, dynamicClass is null. We
       // take advantage of this as core imports js_helper and sees [dynamic]
       // this way.
       withCurrentElement(dynamicClass, () {
         library.addToScope(dynamicClass, this);
       });
     }
     if (uri == Uri.parse('dart:mirrors')) {
       mirrorSystemClass = library.find(const SourceString('MirrorSystem'));
+      metadataHandler = constantHandler;
     } else if (uri == Uri.parse('dart:_collection-dev')) {
       symbolImplementationClass = library.find(const SourceString('Symbol'));
     }
   }
 
   void onClassResolved(ClassElement cls) {
     if (mirrorSystemClass == cls) {
       mirrorSystemGetNameFunction =
         cls.lookupLocalMember(const SourceString('getName'));
     } else if (symbolClass == cls) {
@@ skipping 159 matching lines @@
     }
 
     log('Resolving...');
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
       libraries.forEach((_, lib) => fullyEnqueueLibrary(lib));
     }
     // Elements required by enqueueHelpers are global dependencies
     // that are not pulled in by a particular element.
     backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
+    resolveReflectiveDataIfNeeded();
     processQueue(enqueuer.resolution, main);
     enqueuer.resolution.logSummary(log);
 
     if (compilationFailed) return;
     if (analyzeOnly) return;
     assert(main != null);
     phase = PHASE_DONE_RESOLVING;
 
     // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
     // should know this.
@@ skipping 22 matching lines @@
     processQueue(enqueuer.codegen, main);
     enqueuer.codegen.logSummary(log);
 
     if (compilationFailed) return;
 
     backend.assembleProgram();
 
     checkQueues();
   }
 
+  void resolveReflectiveDataIfNeeded() {
+    // Only need reflective data when dart:mirrors is loaded.
+    if (mirrorSystemClass == null) return;
+
+    for (LibraryElement library in libraries.values) {
+      for (Link link = library.metadata; !link.isEmpty; link = link.tail) {
+        link.head.ensureResolved(this);
+      }
+    }
+  }
+
   void fullyEnqueueLibrary(LibraryElement library) {
     library.forEachLocalMember(fullyEnqueueTopLevelElement);
   }
 
   void fullyEnqueueTopLevelElement(Element element) {
     if (element.isClass()) {
       ClassElement cls = element;
       cls.ensureResolved(this);
       cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
       enqueuer.resolution.registerInstantiatedClass(
@@ skipping 64 matching lines @@
     for (Element e in resolved) {
       SourceSpan span = spanFromElement(e);
       reportDiagnostic(span, 'Warning: $e resolved but not compiled.',
                        api.Diagnostic.WARNING);
     }
   }
 
   TreeElements analyzeElement(Element element) {
     assert(invariant(element, element.isDeclaration));
     assert(!element.isForwardingConstructor);
-    TreeElements elements = enqueuer.resolution.getCachedElements(element);
+    ResolutionEnqueuer world = enqueuer.resolution;
+    TreeElements elements = world.getCachedElements(element);
     if (elements != null) return elements;
     assert(parser != null);
     Node tree = parser.parse(element);
     validator.validate(tree);
     elements = resolver.resolve(element);
     if (elements != null && !analyzeSignaturesOnly) {
       // Only analyze nodes with a corresponding [TreeElements].
       checker.check(tree, elements);
     }
+    world.resolvedElements[element] = elements;
     return elements;
   }
 
   TreeElements analyze(ResolutionWorkItem work, ResolutionEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.resolution)));
     assert(invariant(work.element, !work.isAnalyzed(),
         message: 'Element ${work.element} has already been analyzed'));
     if (progress.elapsedMilliseconds > 500) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_RESOLVING) {
         log('Resolved ${enqueuer.resolution.resolvedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     Element element = work.element;
     TreeElements result = world.getCachedElements(element);
     if (result != null) return result;
     result = analyzeElement(element);
-    assert(invariant(element, element.isDeclaration));
-    world.resolvedElements[element] = result;
     return result;
   }
 
   void codegen(CodegenWorkItem work, CodegenEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.codegen)));
     if (progress.elapsedMilliseconds > 500) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       log('Compiled ${enqueuer.codegen.generatedCode.length} methods.');
       progress.reset();
@@ skipping 339 matching lines @@
 
   void close() {}
 
   toString() => name;
 
   /// Convenience method for getting an [api.CompilerOutputProvider].
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }