Introduce "CommonElements"

pkg/compiler/lib/src/deferred_load.dart

 // Copyright (c) 2014, 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 deferred_load;
 
 import 'common/backend_api.dart' show Backend;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 71 matching lines @@
 }
 
 /// For each deferred import, find elements and constants to be loaded when that
 /// import is loaded. Elements that are used by several deferred imports are in
 /// shared OutputUnits.
 class DeferredLoadTask extends CompilerTask {
   /// The name of this task.
   String get name => 'Deferred Loading';
 
   /// DeferredLibrary from dart:async
-  ClassElement get deferredLibraryClass => compiler.deferredLibraryClass;
+  ClassElement get deferredLibraryClass =>
+      compiler.commonElements.deferredLibraryClass;
 
   /// A synthetic import representing the loading of the main program.
   final _DeferredImport _fakeMainImport = const _DeferredImport();
 
   /// The OutputUnit that will be loaded when the program starts.
   final OutputUnit mainOutputUnit = new OutputUnit(isMainOutput: true);
 
   /// A set containing (eventually) all output units that will result from the
   /// program.
   final Set<OutputUnit> allOutputUnits = new Set<OutputUnit>();
@@ skipping 353 matching lines @@
         }
       }
 
       iterateTags(library);
       if (library.isPatched) {
         iterateTags(library.implementation);
       }
     }
 
     traverseLibrary(root);
-    result.add(compiler.coreLibrary);
+    result.add(compiler.commonElements.coreLibrary);
     return result;
   }
 
   /// Add all dependencies of [constant] to the mapping of [import].
   void _mapConstantDependencies(
       ConstantValue constant, _DeferredImport import) {
     Set<ConstantValue> constants = _constantsDeferredBy.putIfAbsent(
         import, () => new Set<ConstantValue>());
     if (constants.contains(constant)) return;
     constants.add(constant);
@@ skipping 184 matching lines @@
               // are things that the backend needs but cannot associate with a
               // particular element, for example, startRootIsolate.  This set
               // also contains elements for which we lack precise information.
               for (Element element
                   in compiler.globalDependencies.otherDependencies) {
                 _mapDependencies(element: element, import: _fakeMainImport);
               }
 
               // Now check to see if we have to add more elements due to
               // mirrors.
-              if (compiler.mirrorsLibrary != null) {
+              if (compiler.commonElements.mirrorsLibrary != null) {
                 _addMirrorElements();
               }
 
               // Build the OutputUnits using these two maps.
               Map<Element, OutputUnit> elementToOutputUnitBuilder =
                   new Map<Element, OutputUnit>();
               Map<ConstantValue, OutputUnit> constantToOutputUnitBuilder =
                   new Map<ConstantValue, OutputUnit>();
 
               // Reverse the mappings. For each element record an OutputUnit
@@ skipping 332 matching lines @@
       }
     } else {
       // Finds the first argument to the [DeferredLibrary] annotation
       List<MetadataAnnotation> metadatas = declaration.metadata;
       assert(metadatas != null);
       for (MetadataAnnotation metadata in metadatas) {
         metadata.ensureResolved(compiler.resolution);
         ConstantValue value =
             compiler.constants.getConstantValue(metadata.constant);
         Element element = value.getType(compiler.coreTypes).element;
-        if (element == compiler.deferredLibraryClass) {
+        if (element == compiler.commonElements.deferredLibraryClass) {
           ConstructedConstantValue constant = value;
           StringConstantValue s = constant.fields.values.single;
           result = s.primitiveValue.slowToString();
           break;
         }
       }
     }
     assert(result != null);
     return result;
   }
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 
   String toString() => '$declaration';
 }