Implement MirrorUsed.targets for libraries

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 193 matching lines @@
     return classElement == compiler.objectClass;
   }
 
   void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
   void onLibraryScanned(LibraryElement library, Uri uri) {}
 
   void registerMetadataInstantiatedType(DartType type, TreeElements elements) {}
   void registerMetadataStaticUse(Element element) {}
   void registerMetadataGetOfStaticFunction(FunctionElement element) {}
+
+  void registerMirrorUsage(Set<String> symbols,

[Johnni Winther, 2013/07/30 11:15:09]

Please document.

[ahe, 2013/07/30 12:05:45]

Done.

+                           Set<Element> targets,
+                           Set<Element> metaTargets) {}
+
+  bool isNeededForReflection(Element element) => false;

[Johnni Winther, 2013/07/30 11:15:09]

Please document. For instance, is [element] only needed for reflection?

[ahe, 2013/07/30 12:05:45]

Done.

 }
 
 /**
  * Key class used in [TokenMap] in which the hash code for a token is based
  * on the [charOffset].
  */
 class TokenKey {
   final Token token;
   TokenKey(this.token);
   int get hashCode => token.charOffset;
@@ skipping 107 matching lines @@
   CompilerTask measuredTask;
   Element _currentElement;
   LibraryElement coreLibrary;
   LibraryElement isolateLibrary;
   LibraryElement isolateHelperLibrary;
   LibraryElement jsHelperLibrary;
   LibraryElement interceptorsLibrary;
   LibraryElement foreignLibrary;
   LibraryElement mainApp;
 
+  /// Initialized when dart:mirrors is loaded.
+  LibraryElement mirrorsLibrary;
+
   ClassElement objectClass;
   ClassElement closureClass;
   ClassElement boundClosureClass;
   ClassElement dynamicClass;
   ClassElement boolClass;
   ClassElement numClass;
   ClassElement intClass;
   ClassElement doubleClass;
   ClassElement stringClass;
   ClassElement functionClass;
   ClassElement nullClass;
   ClassElement listClass;
   ClassElement typeClass;
   ClassElement mapClass;
   ClassElement symbolClass;
   ClassElement stackTraceClass;
 
   // Initialized after mirrorSystemClass has been resolved.
   FunctionElement symbolConstructor;
 
   // Initialized when dart:mirrors is loaded.
   ClassElement mirrorSystemClass;
 
+  // Initialized when dart:mirrors is loaded.
+  ClassElement mirrorsUsedClass;
+
   // Initialized after mirrorSystemClass has been resolved.
   FunctionElement mirrorSystemGetNameFunction;
 
   // Initialized when dart:_collection-dev is loaded.
   ClassElement symbolImplementationClass;
 
   // Initialized when symbolImplementationClass has been resolved.
   FunctionElement symbolValidatedConstructor;
 
   // Initialized when dart:mirrors is loaded.
@@ skipping 56 matching lines @@
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   ti.TypesTask typesTask;
   Backend backend;
   ConstantHandler constantHandler;
   ConstantHandler metadataHandler;
   EnqueueTask enqueuer;
   CompilerTask fileReadingTask;
   DeferredLoadTask deferredLoadTask;
+  MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   ContainerTracer containerTracer;
   String buildId;
 
   static const SourceString MAIN = const SourceString('main');
   static const SourceString CALL_OPERATOR_NAME = const SourceString('call');
   static const SourceString NO_SUCH_METHOD = const SourceString('noSuchMethod');
   static const int NO_SUCH_METHOD_ARG_COUNT = 1;
   static const SourceString CREATE_INVOCATION_MIRROR =
       const SourceString('createInvocationMirror');
   static const SourceString INVOKE_ON = const SourceString('_invokeOn');
@@ skipping 88 matching lines @@
       dietParser = new DietParserTask(this),
       parser = new ParserTask(this),
       patchParser = new PatchParserTask(this),
       resolver = new ResolverTask(this),
       closureToClassMapper = new closureMapping.ClosureTask(this, closureNamer),
       checker = new TypeCheckerTask(this),
       typesTask = new ti.TypesTask(this),
       containerTracer = new ContainerTracer(this),
       constantHandler = new ConstantHandler(this, backend.constantSystem),
       deferredLoadTask = new DeferredLoadTask(this),
+      mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
       enqueuer = new EnqueueTask(this)];
 
     tasks.addAll(backend.tasks);
     metadataHandler = new ConstantHandler(
         this, backend.constantSystem, isMetadata: true);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
@@ skipping 127 matching lines @@
   void onLibraryScanned(LibraryElement library, Uri uri) {
     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 == new Uri(scheme: 'dart', path: 'mirrors')) {
+      mirrorsLibrary = library;
       mirrorSystemClass =
           findRequiredElement(library, const SourceString('MirrorSystem'));
+      mirrorsUsedClass =
+          findRequiredElement(library, const SourceString('MirrorsUsed'));
     } else if (uri == new Uri(scheme: 'dart', path: '_collection-dev')) {
       symbolImplementationClass =
           findRequiredElement(library, const SourceString('Symbol'));
     } else if (uri == new Uri(scheme: 'dart', path: 'async')) {
       deferredLibraryClass =
           findRequiredElement(library, const SourceString('DeferredLibrary'));
     }
     backend.onLibraryScanned(library, uri);
   }
 
@@ skipping 184 matching lines @@
         FunctionSignature parameters = mainMethod.computeSignature(this);
         parameters.forEachParameter((Element parameter) {
           reportError(
               parameter,
               MessageKind.GENERIC,
               {'text':
                   'Error: "${MAIN.slowToString()}" cannot have parameters.'});
         });
       }
 
+      mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
+
       // In order to see if a library is deferred, we must compute the
       // compile-time constants that are metadata.  This means adding
       // something to the resolution queue.  So we cannot wait with
       // this until after the resolution queue is processed.
       // TODO(ahe): Clean this up, for example, by not enqueueing
       // classes only used for metadata.
       deferredLoadTask.findDeferredLibraries(mainApp);
     }
 
     log('Resolving...');
@@ skipping 263 matching lines @@
                   api.Diagnostic.INFO);
   }
 
   void reportHint(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
     reportMessage(spanFromSpannable(node),
                   errorCode.error(arguments),
                   api.Diagnostic.HINT);
   }
 
+  void reportHere(Spannable node, String debugMessage) {

[Johnni Winther, 2013/07/30 11:15:09]

Document that this is for debugging only.

[ahe, 2013/07/30 12:05:45]

Done.

+    reportInfo(node, MessageKind.GENERIC, {'text': 'HERE: $debugMessage'});
+  }
+
   void reportInternalError(Spannable node, String message) {
     reportError(
         node, MessageKind.GENERIC, {'text': 'Internal Error: $message'});
   }
 
   void reportMessage(SourceSpan span, Diagnostic message, api.Diagnostic kind) {
     // TODO(ahe): The names Diagnostic and api.Diagnostic are in
     // conflict. Fix it.
     reportDiagnostic(span, "$message", kind);
   }
@@ skipping 263 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');
   }
 }