Introduce "CommonElements"

pkg/compiler/lib/src/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 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compile_time_constants.dart' show ConstantCompiler;
 import 'compiler.dart' show Compiler;
@@ skipping 73 matching lines @@
 
   MirrorUsageAnalyzerTask(Compiler compiler)
       : compiler = compiler,
         super(compiler.measurer) {
     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 (mainApp == null || compiler.mirrorsLibrary == null) return;
+    if (mainApp == null || compiler.commonElements.mirrorsLibrary == null) {
+      return;
+    }
     measure(analyzer.run);
     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>.from(symbols),
         targets == null ? null : new Set<Element>.from(targets),
         metaTargets == null ? null : new Set<Element>.from(metaTargets));
     librariesWithUsage = analyzer.librariesWithUsage;
   }
@@ skipping 129 matching lines @@
           usageMap.putIfAbsent(overridden, () => <MirrorUsage>[]);
       usages.addAll(overriddenUsages);
     });
   }
 
   /// Find @MirrorsUsed annotations on the given import [tag] in [library]. The
   /// annotations are represented as [MirrorUsage].
   List<MirrorUsage> mirrorsUsedOnLibraryTag(
       LibraryElement library, ImportElement import) {
     LibraryElement importedLibrary = import.importedLibrary;
-    if (importedLibrary != compiler.mirrorsLibrary) {
+    if (importedLibrary != compiler.commonElements.mirrorsLibrary) {
       return null;
     }
     List<MirrorUsage> result = <MirrorUsage>[];
     for (MetadataAnnotation metadata in import.metadata) {
       metadata.ensureResolved(compiler.resolution);
       ConstantValue value =
           compiler.constants.getConstantValue(metadata.constant);
       Element element = value.getType(compiler.coreTypes).element;
-      if (element == compiler.mirrorsUsedClass) {
+      if (element == compiler.commonElements.mirrorsUsedClass) {
         result.add(buildUsage(value));
       }
     }
     return result;
   }
 
   /// Merge all [MirrorUsage] instances accross all libraries.
   MirrorUsage mergeUsages(Map<LibraryElement, List<MirrorUsage>> usageMap) {
     Set<MirrorUsage> usagesToMerge = new Set<MirrorUsage>();
     usageMap.forEach((LibraryElement library, List<MirrorUsage> usages) {
@@ skipping 42 matching lines @@
     } else if (metaTargets != wildcard && b.metaTargets != null) {
       metaTargets.addAll(b.metaTargets);
     }
     return new MirrorUsage(symbols, targets, metaTargets, null);
   }
 
   /// Convert a [constant] to an instance of [MirrorUsage] using information
   /// that was resolved during [MirrorUsageAnalyzerTask.validate].
   MirrorUsage buildUsage(ConstructedConstantValue constant) {
     Map<Element, ConstantValue> fields = constant.fields;
-    VariableElement symbolsField =
-        compiler.mirrorsUsedClass.lookupLocalMember('symbols');
-    VariableElement targetsField =
-        compiler.mirrorsUsedClass.lookupLocalMember('targets');
-    VariableElement metaTargetsField =
-        compiler.mirrorsUsedClass.lookupLocalMember('metaTargets');
-    VariableElement overrideField =
-        compiler.mirrorsUsedClass.lookupLocalMember('override');
+    ClassElement cls = compiler.commonElements.mirrorsUsedClass;
+    VariableElement symbolsField = cls.lookupLocalMember('symbols');
+    VariableElement targetsField = cls.lookupLocalMember('targets');
+    VariableElement metaTargetsField = cls.lookupLocalMember('metaTargets');
+    VariableElement overrideField = cls.lookupLocalMember('override');
 
     return new MirrorUsage(
         cachedStrings[fields[symbolsField]],
         cachedElements[fields[targetsField]],
         cachedElements[fields[metaTargetsField]],
         cachedElements[fields[overrideField]]);
   }
 }
 
 /// Used to represent a resolved MirrorsUsed constant.
@@ skipping 231 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }