Introduce "CommonElements"

pkg/compiler/lib/src/elements/elements.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.
 
 library elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart';
@@ skipping 657 matching lines @@
     if (identical(op, '>>=')) return '>>';
     if (identical(op, '&=')) return '&';
     if (identical(op, '^=')) return '^';
     if (identical(op, '|=')) return '|';
     if (identical(op, '??=')) return '??';
 
     return null;
   }
 
   static bool isNumberOrStringSupertype(Element element, Compiler compiler) {
-    LibraryElement coreLibrary = compiler.coreLibrary;
+    LibraryElement coreLibrary = compiler.commonElements.coreLibrary;
     return (element == coreLibrary.find('Comparable'));
   }
 
   static bool isStringOnlySupertype(Element element, Compiler compiler) {
-    LibraryElement coreLibrary = compiler.coreLibrary;
+    LibraryElement coreLibrary = compiler.commonElements.coreLibrary;
     return element == coreLibrary.find('Pattern');
   }
 
   static bool isListSupertype(Element element, Compiler compiler) {
-    LibraryElement coreLibrary = compiler.coreLibrary;
+    LibraryElement coreLibrary = compiler.commonElements.coreLibrary;
     return element == coreLibrary.find('Iterable');
   }
 
   /// A `compareTo` function that places [Element]s in a consistent order based
   /// on the source code order.
   static int compareByPosition(Element a, Element b) {
     if (identical(a, b)) return 0;
     int r = _compareLibraries(a.library, b.library);
     if (r != 0) return r;
     r = _compareCompilationUnits(a.compilationUnit, b.compilationUnit);
@@ skipping 88 matching lines @@
       Element element, Send node, Compiler compiler) {
     return element == compiler.filledListConstructor &&
         node.isCall &&
         !node.arguments.isEmpty &&
         !node.arguments.tail.isEmpty &&
         node.arguments.tail.tail.isEmpty;
   }
 
   static bool isConstructorOfTypedArraySubclass(
       Element element, Compiler compiler) {
-    if (compiler.typedDataLibrary == null) return false;
+    if (compiler.commonElements.typedDataLibrary == null) return false;
     if (!element.isConstructor) return false;
     ConstructorElement constructor = element.implementation;
     constructor = constructor.effectiveTarget;
     ClassElement cls = constructor.enclosingClass;
-    return cls.library == compiler.typedDataLibrary &&
+    return cls.library == compiler.commonElements.typedDataLibrary &&
         compiler.backend.isNative(cls) &&
-        compiler.world.isSubtypeOf(cls, compiler.typedDataClass) &&
+        compiler.world
+            .isSubtypeOf(cls, compiler.commonElements.typedDataClass) &&
         compiler.world.isSubtypeOf(cls, compiler.coreClasses.listClass) &&
         constructor.name == '';
   }
 
   static bool switchStatementHasContinue(
       SwitchStatement node, TreeElements elements) {
     for (SwitchCase switchCase in node.cases) {
       for (Node labelOrCase in switchCase.labelsAndCases) {
         Node label = labelOrCase.asLabel();
         if (label != null) {
@@ skipping 1092 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }