Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/universe/function_set.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 universe.function_set;
 
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
 import '../types/types.dart';
@@ skipping 65 matching lines @@
     return query(selector, constraint).computeMask(closedWorld);
   }
 
   SelectorMask _createSelectorMask(Selector selector,
       ReceiverConstraint constraint, ClosedWorld closedWorld) {
     return constraint != null
         ? new SelectorMask(selector, constraint)
         : new SelectorMask(
             selector,
             new TypeMask.subclass(
-                closedWorld.coreClasses.objectClass, closedWorld));
+                closedWorld.commonElements.objectClass, closedWorld));
   }
 
   /// Returns the set of functions that can be the target of a call to
   /// [selector] on a receiver constrained by [constraint] including
   /// 'noSuchMethod' methods where applicable.
   FunctionSetQuery query(Selector selector, ReceiverConstraint constraint) {
     String name = selector.name;
     SelectorMask selectorMask =
         _createSelectorMask(selector, constraint, closedWorld);
     SelectorMask noSuchMethodMask =
@@ skipping 184 matching lines @@
 class FullFunctionSetQuery implements FunctionSetQuery {
   @override
   final Iterable<Element> functions;
 
   TypeMask _mask;
 
   FullFunctionSetQuery(this.functions);
 
   @override
   TypeMask computeMask(ClosedWorld closedWorld) {
-    assert(
-        closedWorld.hasAnyStrictSubclass(closedWorld.coreClasses.objectClass));
+    assert(closedWorld
+        .hasAnyStrictSubclass(closedWorld.commonElements.objectClass));
     if (_mask != null) return _mask;
     return _mask = new TypeMask.unionOf(
         functions.expand((element) {
           ClassElement cls = element.enclosingClass;
           return [cls]..addAll(closedWorld.mixinUsesOf(cls));
         }).map((cls) {
           if (closedWorld.backendClasses.nullImplementation == cls) {
             return const TypeMask.empty();
           } else if (closedWorld.isInstantiated(cls.declaration)) {
             return new TypeMask.nonNullSubclass(cls.declaration, closedWorld);
           } else {
             // TODO(johnniwinther): Avoid the need for this case.
             return const TypeMask.empty();
           }
         }),
         closedWorld);
   }
 }