Only retain needed metadata constants.

dart/tests/compiler/dart2js/mirrors_used_test.dart

 // Copyright (c) 2013, 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.
 
 /// Test that the @MirrorsUsed annotation suppress hints and that only
 /// requested elements are retained for reflection.
 library dart2js.test.mirrors_used_test;
 
 import 'package:expect/expect.dart';
 
 import 'memory_compiler.dart' show
     compilerFor;
 
 import '../../../sdk/lib/_internal/compiler/implementation/apiimpl.dart' show
     Compiler;
 
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart' show
-    SourceString;
+    Constant,
+    SourceString,
+    TypeConstant;
 
 import
     '../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart'
 show
     Elements;
 
 void expectOnlyVerboseInfo(Uri uri, int begin, int end, String message, kind) {
   if (kind.name == 'verbose info') {
     print(message);
     return;
@@ skipping 48 matching lines @@
           Expect.isTrue(
               compiler.backend.isNeededForReflection(classMember),
               '$classMember');
         });
       } else {
         Expect.isFalse(
             compiler.backend.isNeededForReflection(member), '$member');
       }
     });
   }
+
+  // There should at least be three metadata constants:
+  // 1. The type literal 'Foo'.
+  // 2. The list 'const [Foo]'.
+  // 3. The constructed constant for 'MirrorsUsed'.
+  Expect.isTrue(compiler.metadataHandler.compiledConstants.length >= 3);
+
+  // Make sure that most of the metadata constants aren't included in the
+  // generated code.
+  for (Constant constant in compiler.metadataHandler.compiledConstants) {
+    if (constant is TypeConstant && '${constant.representedType}' == 'Foo') {
+      // The type literal 'Foo' is retained as a constant because it is being
+      // passed to reflectClass.
+      continue;
+    }
+    Expect.isFalse(
+        compiler.constantHandler.compiledConstants.contains(constant),
+        '$constant');
+  }
+
+  // The type literal 'Foo' is both used as metadata, and as a plain value in
+  // the program. Make sure that it isn't duplicated.
+  int fooConstantCount = 0;
+  for (Constant constant in compiler.metadataHandler.compiledConstants) {
+    if (constant is TypeConstant && '${constant.representedType}' == 'Foo') {
+      fooConstantCount++;
+    }
+  }
+  Expect.equals(
+      1, fooConstantCount, "The type literal 'Foo' is duplicated or missing.");
 }
 
 const MEMORY_SOURCE_FILES = const <String, String> {
   'main.dart': """
 @MirrorsUsed(targets: const [Foo], override: '*')
 import 'dart:mirrors';
 
 import 'library.dart';
 
 class Foo {
@@ skipping 13 matching lines @@
 library lib;
 
 import 'dart:mirrors';
 
 useReflect(type) {
   print(new Symbol('Foo'));
   print(MirrorSystem.getName(reflectClass(type).owner.qualifiedName));
 }
 """,
 };