MirrorsUsed values are interpreted differently based on position, so they must be cached in differe…

dart/sdk/lib/_internal/compiler/implementation/mirrors_used.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.
 
 library dart2js.mirrors_used;
 
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     Constant,
@@ skipping 87 matching lines @@
   MirrorUsageAnalyzerTask(Compiler compiler)
       : super(compiler) {
     analyzer = new MirrorUsageAnalyzer(compiler, this);
   }
 
   /// Collect @MirrorsUsed annotations in all libraries.  Called by the
   /// compiler after all libraries are loaded, but before resolution.
   void analyzeUsage(LibraryElement mainApp) {
     if (compiler.mirrorsLibrary == null) return;
     measure(analyzer.run);
-    List /*<String|Element>*/ symbols = analyzer.mergedMirrorUsage.symbols;
+    List<String> symbols = analyzer.mergedMirrorUsage.symbols;
     List<Element> targets = analyzer.mergedMirrorUsage.targets;
     List<Element> metaTargets = analyzer.mergedMirrorUsage.metaTargets;
     compiler.backend.registerMirrorUsage(
-        symbols == null ? null : new Set/*<String|Element>*/.from(symbols),
+        symbols == null ? null : new Set<String>.from(symbols),
         targets == null ? null : new Set<Element>.from(targets),
         metaTargets == null ? null : new Set<Element>.from(metaTargets));
     librariesWithUsage = analyzer.librariesWithUsage;
   }
 
   /// Is there a @MirrorsUsed annotation in the library of [element]?  Used by
   /// the resolver to suppress hints about using new Symbol or
   /// MirrorSystem.getName.
   bool hasMirrorUsage(Element element) {
     LibraryElement library = element.getLibrary();
@@ skipping 16 matching lines @@
       ConstantMapper mapper =
           new ConstantMapper(compiler.constantHandler, mapping, compiler);
       named.expression.accept(mapper);
 
       MirrorUsageBuilder builder =
           new MirrorUsageBuilder(
               analyzer, mapping.currentElement.getLibrary(), named.expression,
               value, mapper.constantToNodeMap);
 
       if (named.name.source == 'symbols') {
-        analyzer.cachedValues[value] =
+        analyzer.cachedStrings[value] =
             builder.convertToListOfStrings(
                 builder.convertConstantToUsageList(value, onlyStrings: true));
       } else if (named.name.source == 'targets') {
-        analyzer.cachedValues[value] =
+        analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'metaTargets') {
-        analyzer.cachedValues[value] =
+        analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'override') {
-        analyzer.cachedValues[value] =
+        analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       }
     }
   }
 }
 
 class MirrorUsageAnalyzer {
   final Compiler compiler;
   final MirrorUsageAnalyzerTask task;
   List<LibraryElement> wildcard;
   final Set<LibraryElement> librariesWithUsage;
-  final Map<Constant, List> cachedValues;
+  final Map<Constant, List<String>> cachedStrings;
+  final Map<Constant, List<Element>> cachedElements;
   MirrorUsage mergedMirrorUsage;
 
   MirrorUsageAnalyzer(Compiler compiler, this.task)
       : compiler = compiler,
         librariesWithUsage = new Set<LibraryElement>(),
-        cachedValues = new Map<Constant, List>();
+        cachedStrings = new Map<Constant, List<String>>(),
+        cachedElements = new Map<Constant, List<Element>>();
 
   /// Collect and merge all @MirrorsUsed annotations. As a side-effect, also
   /// compute which libraries have the annotation (which is used by
   /// [MirrorUsageAnalyzerTask.hasMirrorUsage]).
   void run() {
     wildcard = compiler.libraries.values.toList();
     Map<LibraryElement, List<MirrorUsage>> usageMap =
         collectMirrorsUsedAnnotation();
     propagateOverrides(usageMap);
     Set<LibraryElement> librariesWithoutUsage = new Set<LibraryElement>();
@@ skipping 109 matching lines @@
   /// ignored.
   MirrorUsage merge(MirrorUsage a, MirrorUsage b) {
     // TOOO(ahe): Should be an instance method on MirrorUsage.
     if (a.symbols == null && a.targets == null && a.metaTargets == null) {
       return b;
     } else if (
         b.symbols == null && b.targets == null && b.metaTargets == null) {
       return a;
     }
     // TODO(ahe): Test the following cases.
-    List /*<String|Element>*/ symbols = a.symbols;
+    List<String> symbols = a.symbols;
     if (symbols == null) {
       symbols = b.symbols;
     } else if (b.symbols != null) {
       symbols.addAll(b.symbols);
     }
     List<Element> targets = a.targets;
     if (targets == null) {
       targets = b.targets;
     } else if (targets != wildcard && b.targets != null) {
       targets.addAll(b.targets);
@@ skipping 15 matching lines @@
         'symbols');
     VariableElement targetsField = compiler.mirrorsUsedClass.lookupLocalMember(
         'targets');
     VariableElement metaTargetsField =
         compiler.mirrorsUsedClass.lookupLocalMember(
             'metaTargets');
     VariableElement overrideField = compiler.mirrorsUsedClass.lookupLocalMember(
         'override');
 
     return new MirrorUsage(
-        cachedValues[fields[symbolsField]],
-        cachedValues[fields[targetsField]],
-        cachedValues[fields[metaTargetsField]],
-        cachedValues[fields[overrideField]]);
+        cachedStrings[fields[symbolsField]],
+        cachedElements[fields[targetsField]],
+        cachedElements[fields[metaTargetsField]],
+        cachedElements[fields[overrideField]]);
   }
 }
 
 /// Used to represent a resolved MirrorsUsed constant.
 class MirrorUsage {
-  final List /* <String|Element> */ symbols;
+  final List<String> symbols;
   final List<Element> targets;
   final List<Element> metaTargets;
   final List<Element> override;
 
   MirrorUsage(this.symbols, this.targets, this.metaTargets, this.override);
 
   String toString() {
     return
         'MirrorUsage('
         'symbols = $symbols, '
@@ skipping 226 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }