Generate less code when importing dart:mirrors.

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 122 matching lines @@
   void registerInstantiatedClass(ClassElement cls,
                                  Enqueuer enqueuer,
                                  TreeElements elements) {}
   void registerStringInterpolation(TreeElements elements) {}
   void registerCatchStatement(Enqueuer enqueuer,
                               TreeElements elements) {}
   void registerWrapException(TreeElements elements) {}
   void registerThrowExpression(TreeElements elements) {}
   void registerLazyField(TreeElements elements) {}
   void registerTypeVariableExpression(TreeElements elements) {}
-  void registerTypeLiteral(TreeElements elements) {}
+  void registerTypeLiteral(Element element, TreeElements elements) {}
   void registerStackTraceInCatch(TreeElements elements) {}
   void registerIsCheck(DartType type,
                        Enqueuer enqueuer,
                        TreeElements elements) {}
   void registerAsCheck(DartType type, TreeElements elements) {}
   void registerThrowNoSuchMethod(TreeElements elements) {}
   void registerThrowRuntimeError(TreeElements elements) {}
   void registerAbstractClassInstantiation(TreeElements elements) {}
   void registerFallThroughError(TreeElements elements) {}
   void registerSuperNoSuchMethod(TreeElements elements) {}
   void registerConstantMap(TreeElements elements) {}
   void registerRuntimeType(TreeElements elements) {}
 
   void registerRequiredType(DartType type, Element enclosingElement) {}
   void registerClassUsingVariableExpression(ClassElement cls) {}
 
+  void registerConstSymbol(String name, TreeElements elements) {}
+  void registerNewSymbol(TreeElements elements) {}
+
   bool isNullImplementation(ClassElement cls) {
     return cls == compiler.nullClass;
   }
   ClassElement get intImplementation => compiler.intClass;
   ClassElement get doubleImplementation => compiler.doubleClass;
   ClassElement get numImplementation => compiler.numClass;
   ClassElement get stringImplementation => compiler.stringClass;
   ClassElement get listImplementation => compiler.listClass;
   ClassElement get growableListImplementation => compiler.listClass;
   ClassElement get fixedListImplementation => compiler.listClass;
   ClassElement get constListImplementation => compiler.listClass;
   ClassElement get mapImplementation => compiler.mapClass;
   ClassElement get constMapImplementation => compiler.mapClass;
   ClassElement get functionImplementation => compiler.functionClass;
   ClassElement get typeImplementation => compiler.typeClass;
   ClassElement get boolImplementation => compiler.boolClass;
   ClassElement get nullImplementation => compiler.nullClass;
 
   ClassElement defaultSuperclass(ClassElement element) => compiler.objectClass;
 
   bool isDefaultNoSuchMethodImplementation(Element element) {
     assert(element.name == Compiler.NO_SUCH_METHOD);
     ClassElement classElement = element.getEnclosingClass();
     return classElement == compiler.objectClass;
   }
 
-  void enableMirrors() {}
+  void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
-  void registerStaticUse(Element element, Enqueuer enqueuer) {}
+  void onLibraryScanned(LibraryElement library, Uri uri) {}
+
+  void registerMetadataInstantiatedClass(ClassElement element,
+                                         TreeElements elements) {}
+  void registerMetadataStaticUse(Element element) {}
+  void registerMetadataGetOfStaticFunction(FunctionElement element) {}
 }
 
 /**
  * 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 323 matching lines @@
     tasks.addAll(backend.tasks);
     metadataHandler = new ConstantHandler(
         this, backend.constantSystem, isMetadata: true);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
 
-  bool get mirrorsEnabled => mirrorSystemClass != null;
-
   bool get analyzeAll => analyzeAllFlag || compileAll;
 
   bool get compileAll => false;
 
   bool get disableTypeInference {
     return disableTypeInferenceFlag || disableTypeInferenceForMirrors;
   }
 
   int getNextFreeClassId() => nextFreeClassId++;
 
@@ skipping 123 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'));
-      backend.enableMirrors();
-      metadataHandler = constantHandler;
     } else if (uri == Uri.parse('dart:_collection-dev')) {
       symbolImplementationClass = library.find(const SourceString('Symbol'));
     }
+    backend.onLibraryScanned(library, uri);
   }
 
   void onClassResolved(ClassElement cls) {
     if (mirrorSystemClass == cls) {
       mirrorSystemGetNameFunction =
         cls.lookupLocalMember(const SourceString('getName'));
     } else if (symbolClass == cls) {
       symbolConstructor = cls.constructors.head;
     } else if (symbolImplementationClass == cls) {
       symbolValidatedConstructor = symbolImplementationClass.lookupConstructor(
@@ skipping 167 matching lines @@
 
     log('Resolving...');
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
       libraries.forEach(
           (_, lib) => fullyEnqueueLibrary(lib, enqueuer.resolution));
     }
     // 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 25 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 (!mirrorsEnabled) 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, Enqueuer world) {
     void enqueueAll(Element element) {
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass()) {
       ClassElement cls = element;
@@ skipping 478 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');
   }
 }