Only retain needed metadata constants.

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 1402 matching lines @@
   /// Should [name] be retained for reflection?
   bool shouldRetainName(SourceString name) {
     if (hasInsufficientMirrorsUsed) return mustPreserveNames;
     if (name == const SourceString('')) return false;
     return symbolsUsed.contains(name.slowToString());
   }
 
   bool get rememberLazies => isTreeShakingDisabled;
 
   bool retainMetadataOf(Element element) {
-    if (mustRetainMetadata) {
-      // TODO(ahe): This is a little hacky, but I'll have to rewrite this when
-      // implementing @MirrorsUsed anyways.
-      compiler.constantHandler.compiledConstants.addAll(
-          compiler.metadataHandler.compiledConstants);
-      compiler.metadataHandler.compiledConstants.clear();
+    if (mustRetainMetadata) hasRetainedMetadata = true;
+    if (mustRetainMetadata && isNeededForReflection(element)) {
+      for (MetadataAnnotation metadata in element.metadata) {
+        metadata.value.accept(new ConstantCopier(compiler.constantHandler));
+      }
+      return true;
     }
-    if (mustRetainMetadata) hasRetainedMetadata = true;
-    return mustRetainMetadata;
+    return false;
   }
 
   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 =
@@ skipping 60 matching lines @@
       }
       return true;
     }
 
     if (!metaTargetsUsed.isEmpty) {
       // TODO(ahe): Implement this.
       return registerNameOf(element);
     }
 
     if (!targetsUsed.isEmpty) {
-      for (Element e = element; e != null; e = e.enclosingElement) {
-        if (targetsUsed.contains(e)) return registerNameOf(element);
+      if (targetsUsed.contains(element)) return registerNameOf(element);
+      Element enclosing = element.enclosingElement;
+      if (enclosing != null && isNeededForReflection(enclosing)) {
+        return registerNameOf(element);
       }
     }
+
+    if (element is ClosureClassElement) {
+      // TODO(ahe): Try to fix the enclosing element of ClosureClassElement
+      // instead.
+      ClosureClassElement closureClass = element;
+      if (isNeededForReflection(closureClass.methodElement)) {
+        return registerNameOf(element);
+      }
+    }
+
     return false;
   }
 }
 
 /// Records that [type] is used by [user.element].
 class Dependency {
   final DartType type;
   final TreeElements user;
 
   const Dependency(this.type, this.user);
 }
+
+/// Used to copy metadata to the the actual constant handler.
+class ConstantCopier implements ConstantVisitor {
+  final ConstantHandler target;
+
+  ConstantCopier(this.target);
+
+  void copy(Constant constant) {
+    target.compiledConstants.add(constant);
+  }
+
+  void copyAll(List<Constant> constants) {
+    target.compiledConstants.addAll(constants);
+  }
+
+  void visitFunction(FunctionConstant constant) => copy(constant);
+
+  void visitNull(NullConstant constant) => copy(constant);
+
+  void visitInt(IntConstant constant) => copy(constant);
+
+  void visitDouble(DoubleConstant constant) => copy(constant);
+
+  void visitTrue(TrueConstant constant) => copy(constant);
+
+  void visitFalse(FalseConstant constant) => copy(constant);
+
+  void visitString(StringConstant constant) => copy(constant);
+
+  void visitType(TypeConstant constant) => copy(constant);
+
+  void visitInterceptor(InterceptorConstant constant) => copy(constant);
+
+  void visitList(ListConstant constant) {
+    copyAll(constant.entries);
+    copy(constant);
+  }
+  void visitMap(MapConstant constant) {
+    copy(constant.keys);

[ngeoffray, 2013/08/13 11:46:44]

Why is that not copyAll? Maybe add a comment.

[ahe, 2013/08/13 15:09:07]

That's a bug. Made the copy method test the type instead as you suggested.

+    copyAll(constant.values);
+    copy(constant.protoValue);
+    copy(constant);
+  }
+
+  void visitConstructed(ConstructedConstant constant) {
+    copyAll(constant.fields);
+    copy(constant);
+  }
+}