Generate less code when importing dart:mirrors.

dart/sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 138 matching lines @@
   final RuntimeTypes rti;
 
   /// Holds the method "disableTreeShaking" in js_mirrors when
   /// dart:mirrors has been loaded.
   FunctionElement disableTreeShakingMarker;
 
   /// Holds the method "preserveNames" in js_mirrors when
   /// dart:mirrors has been loaded.
   FunctionElement preserveNamesMarker;
 
+  /// Holds the method "preserveMetadata" in js_mirrors when
+  /// dart:mirrors has been loaded.
+  FunctionElement preserveMetadataMarker;
+
+  /// True if a call to preserveMetadataMarker has been seen.  This means that
+  /// metadata must be retained for dart:mirrors to work correctly.
+  bool mustRetainMetadata = false;
+
+  /// True if any metadata has been retained.  This is slightly different from
+  /// [mustRetainMetadata] and tells us if any metadata was retained.  For
+  /// example, if [mustRetainMetadata] is true but there is no metadata in the
+  /// program, this variable will stil be false.
+  bool hasRetainedMetadata = false;
+
+  /// True if a call to preserveNames has been seen.
+  bool mustPreserveNames = false;
+
+  /// True if a call to disableTreeShaking has been seen.
+  bool isTreeShakingDisabled = false;
+
+  /// List of instantiated classes from metadata.  If metadata must be
+  /// preserved, these classes must registered.
+  final List<Dependency> metadataInstantiatedClasses = <Dependency>[];
+
+  /// List of elements used from metadata.  If metadata must be preserved,
+  /// these elements must be compiled.
+  final List<Element> metadataStaticUse = <Element>[];
+
+  /// List of tear-off functions referenced from metadata.  If metadata must be
+  /// preserved, these elements must be compiled.
+  final List<FunctionElement> metadataGetOfStaticFunction = <FunctionElement>[];
+
   JavaScriptBackend(Compiler compiler, bool generateSourceMap, bool disableEval)
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = disableEval
         ? new CodeEmitterNoEvalTask(compiler, namer, generateSourceMap)
         : new CodeEmitterTask(compiler, namer, generateSourceMap);
@@ skipping 421 matching lines @@
   }
 
   void registerThrowExpression(TreeElements elements) {
     enqueueInResolution(getThrowExpressionHelper(), elements);
   }
 
   void registerLazyField(TreeElements elements) {
     enqueueInResolution(getCyclicThrowHelper(), elements);
   }
 
-  void registerTypeLiteral(TreeElements elements) {
+  void registerTypeLiteral(Element element, TreeElements elements) {
     enqueueInResolution(getCreateRuntimeType(), elements);
+    // TODO(ahe): Might want to register [element] as an instantiated class
+    // when reflection is used.  However, as long as we disable tree-shaking
+    // eagerly it doesn't matter.
   }
 
   void registerStackTraceInCatch(TreeElements elements) {
     enqueueInResolution(getTraceFromException(), elements);
   }
 
   void registerSetRuntimeType(TreeElements elements) {
     enqueueInResolution(getSetRuntimeTypeInfo(), elements);
   }
 
@@ skipping 491 matching lines @@
   ClassElement get listImplementation => jsArrayClass;
   ClassElement get constListImplementation => jsArrayClass;
   ClassElement get fixedListImplementation => jsFixedArrayClass;
   ClassElement get growableListImplementation => jsExtendableArrayClass;
   ClassElement get mapImplementation => mapLiteralClass;
   ClassElement get constMapImplementation => constMapLiteralClass;
   ClassElement get typeImplementation => typeLiteralClass;
   ClassElement get boolImplementation => jsBoolClass;
   ClassElement get nullImplementation => jsNullClass;
 
-  void enableMirrors() {
-    LibraryElement library = compiler.libraries['dart:_js_mirrors'];
-    disableTreeShakingMarker =
-        library.find(const SourceString('disableTreeShaking'));
-    preserveNamesMarker =
-        library.find(const SourceString('preserveNames'));
- }
-
   void registerStaticUse(Element element, Enqueuer enqueuer) {
     if (element == disableTreeShakingMarker) {
       enqueuer.enqueueEverything();
+      if (isTreeShakingDisabled) return;
       compiler.disableTypeInferenceForMirrors = true;
+      isTreeShakingDisabled = true;
     } else if (element == preserveNamesMarker) {
+      if (mustPreserveNames) return;
+      mustPreserveNames = true;
+      compiler.log('Preserving names.');
+    } else if (element == preserveMetadataMarker) {
+      if (mustRetainMetadata) return;
+      compiler.log('Retaining metadata.');
+      mustRetainMetadata = true;
+      for (LibraryElement library in compiler.libraries.values) {
+        if (retainMetadataOf(library)) {
+          for (Link link = library.metadata; !link.isEmpty; link = link.tail) {
+            link.head.ensureResolved(compiler);
+          }
+        }
+      }
+      for (Dependency dependency in metadataInstantiatedClasses) {
+        registerMetadataInstantiatedClass(dependency.element, dependency.user);
+      }
+      metadataInstantiatedClasses.clear();
+      for (Element e in metadataStaticUse) {
+        registerMetadataStaticUse(e);
+      }
+      metadataStaticUse.clear();
+      for (Element e in metadataGetOfStaticFunction) {
+        registerMetadataGetOfStaticFunction(e);
+      }
+      metadataGetOfStaticFunction.clear();
+    }
+  }
+
+  /// Called when [:const Symbol(name):] is seen.
+  void registerConstSymbol(String name, TreeElements elements) {
+  }
+
+  /// Called when [:new Symbol(...):] is seen.
+  void registerNewSymbol(TreeElements elements) {
+  }
+
+  bool retainGetter(Element element) => isTreeShakingDisabled;
+
+  bool retainSetter(Element element) => isTreeShakingDisabled;
+
+  bool retainName(SourceString name) => mustPreserveNames;
+
+  bool retainMetadataOf(Element element) {
+    if (mustRetainMetadata) hasRetainedMetadata = true;
+    return mustRetainMetadata;
+  }
+
+  void onLibraryScanned(LibraryElement library, Uri uri) {
+    if (uri == Uri.parse('dart:_js_mirrors')) {
+      disableTreeShakingMarker =
+          library.find(const SourceString('disableTreeShaking'));
+      preserveMetadataMarker =
+          library.find(const SourceString('preserveMetadata'));
+    } else if (uri == Uri.parse('dart:_js_names')) {
+      preserveNamesMarker =
+          library.find(const SourceString('preserveNames'));
+    }
+  }
+
+  void registerMetadataInstantiatedClass(ClassElement element,
+                                         TreeElements elements) {
+    if (mustRetainMetadata) {
+      compiler.constantHandler.registerInstantiatedClass(element, elements);
+    } else {
+      metadataInstantiatedClasses.add(new Dependency(element, elements));
+    }
+  }
+
+  void registerMetadataStaticUse(Element element) {
+    if (mustRetainMetadata) {
+      compiler.constantHandler.registerStaticUse(element);
+    } else {
+      metadataStaticUse.add(element);
+    }
+  }
+
+  void registerMetadataGetOfStaticFunction(FunctionElement element) {
+    if (mustRetainMetadata) {
+      compiler.constantHandler.registerGetOfStaticFunction(element);
+    } else {
+      metadataGetOfStaticFunction.add(element);
     }
   }
 }
+
+/// Records that [element] is used by [user.element].
+class Dependency {
+  final Element element;
+  final TreeElements user;
+
+  const Dependency(this.element, this.user);
+}