Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/js_backend/backend.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 js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/backend_api.dart'
     show
         Backend,
         BackendClasses,
         ImpactTransformer,
         ForeignResolver,
         NativeRegistry;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
 import '../common/names.dart' show Identifiers, Uris;
 import '../common/resolution.dart' show Frontend, Resolution, ResolutionImpact;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show CommonElements, CoreClasses, CoreTypes;
+import '../core_types.dart' show CommonElements;
 import '../dart_types.dart';
 import '../deferred_load.dart' show DeferredLoadTask;
 import '../dump_info.dart' show DumpInfoTask;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../enqueue.dart'
     show Enqueuer, ResolutionEnqueuer, TreeShakingEnqueuerStrategy;
 import '../io/position_information.dart' show PositionSourceInformationStrategy;
 import '../io/source_information.dart' show SourceInformationStrategy;
 import '../io/start_end_information.dart'
@@ skipping 561 matching lines @@
     serialization = new JavaScriptBackendSerialization(this);
     backendClasses = new JavaScriptBackendClasses(helpers);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CommonElements get commonElements => compiler.commonElements;
 
-  CoreClasses get coreClasses => compiler.coreClasses;
-
-  CoreTypes get coreTypes => compiler.coreTypes;
-
   Resolution get resolution => compiler.resolution;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
   @override
   bool isDefaultNoSuchMethod(MethodElement element) {
@@ skipping 51 matching lines @@
     }
     return element;
   }
 
   bool _isValidBackendUse(Element element) {
     assert(invariant(element, element.isDeclaration, message: ""));
     if (element == helpers.streamIteratorConstructor ||
         compiler.commonElements.isSymbolConstructor(element) ||
         helpers.isSymbolValidatedConstructor(element) ||
         element == helpers.syncCompleterConstructor ||
-        element == coreClasses.symbolClass ||
+        element == commonElements.symbolClass ||
         element == helpers.objectNoSuchMethod) {
       // TODO(johnniwinther): These are valid but we could be more precise.
       return true;
     } else if (element.implementationLibrary.isPatch ||
         // Needed to detect deserialized injected elements, that is
         // element declared in patch files.
         (element.library.isPlatformLibrary &&
             element.sourcePosition.uri.path
                 .contains('_internal/js_runtime/lib/')) ||
         element.library == helpers.jsHelperLibrary ||
         element.library == helpers.interceptorsLibrary ||
         element.library == helpers.isolateHelperLibrary) {
       // TODO(johnniwinther): We should be more precise about these.
       return true;
-    } else if (element == coreClasses.listClass ||
+    } else if (element == commonElements.listClass ||
         element == helpers.mapLiteralClass ||
-        element == coreClasses.functionClass ||
-        element == coreClasses.stringClass) {
+        element == commonElements.functionClass ||
+        element == commonElements.stringClass) {
       // TODO(johnniwinther): Avoid these.
       return true;
     } else if (element == helpers.genericNoSuchMethod ||
         element == helpers.unresolvedConstructorError ||
         element == helpers.malformedTypeError) {
       return true;
     }
     return false;
   }
 
@@ skipping 257 matching lines @@
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
     return specialOperatorEqClasses.contains(operatorEqfunction.enclosingClass);
   }
 
   void validateInterceptorImplementsAllObjectMethods(
       ClassElement interceptorClass) {
     if (interceptorClass == null) return;
     interceptorClass.ensureResolved(resolution);
-    coreClasses.objectClass.forEachMember((_, Element member) {
+    commonElements.objectClass.forEachMember((_, Element member) {
       if (member.isGenerativeConstructor) return;
       Element interceptorMember = interceptorClass.lookupMember(member.name);
       // Interceptors must override all Object methods due to calling convention
       // differences.
       assert(invariant(interceptorMember,
           interceptorMember.enclosingClass == interceptorClass,
           message:
               "Member ${member.name} not overridden in ${interceptorClass}. "
               "Found $interceptorMember from "
               "${interceptorMember.enclosingClass}."));
     });
   }
 
   void addInterceptorsForNativeClassMembers(ClassElement cls,
       {bool forResolution}) {
     if (forResolution) {
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.name == Identifiers.call) {
           return;
         }
         if (member.isSynthesized) return;
         // All methods on [Object] are shadowed by [Interceptor].
-        if (classElement == coreClasses.objectClass) return;
+        if (classElement == commonElements.objectClass) return;
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
       }, includeSuperAndInjectedMembers: true);
 
       // Walk superclass chain to find mixins.
       for (; cls != null; cls = cls.superclass) {
         if (cls.isMixinApplication) {
           MixinApplicationElement mixinApplication = cls;
           classesMixedIntoInterceptedClasses.add(mixinApplication.mixin);
         }
       }
     }
   }
 
   void addInterceptors(ClassElement cls, WorldImpactBuilder impactBuilder,
       {bool forResolution}) {
     if (forResolution) {
       if (_interceptedClasses.add(cls)) {
         cls.ensureResolved(resolution);
         cls.forEachMember((ClassElement classElement, Element member) {
           // All methods on [Object] are shadowed by [Interceptor].
-          if (classElement == coreClasses.objectClass) return;
+          if (classElement == commonElements.objectClass) return;
           Set<Element> set = interceptedElements.putIfAbsent(
               member.name, () => new Set<Element>());
           set.add(member);
         }, includeSuperAndInjectedMembers: true);
       }
       _interceptedClasses.add(helpers.jsInterceptorClass);
     }
     impactTransformer.registerBackendInstantiation(impactBuilder, cls);
   }
 
@@ skipping 29 matching lines @@
           dependency, impactBuilder, isForResolution);
     }
   }
 
   void addCompileTimeConstantForEmission(ConstantValue constant) {
     constants.addCompileTimeConstantForEmission(constant);
   }
 
   void computeImpactForCompileTimeConstantInternal(ConstantValue constant,
       WorldImpactBuilder impactBuilder, bool isForResolution) {
-    DartType type = constant.getType(compiler.coreTypes);
+    DartType type = constant.getType(compiler.commonElements);
     computeImpactForInstantiatedConstantType(type, impactBuilder);
 
     if (constant.isFunction) {
       FunctionConstantValue function = constant;
       impactBuilder
           .registerStaticUse(new StaticUse.staticTearOff(function.element));
     } else if (constant.isInterceptor) {
       // An interceptor constant references the class's prototype chain.
       InterceptorConstantValue interceptor = constant;
       computeImpactForInstantiatedConstantType(
           interceptor.dispatchedType, impactBuilder);
     } else if (constant.isType) {
       if (isForResolution) {
         impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
             helpers.createRuntimeType,
             null));
         registerBackendUse(helpers.createRuntimeType);
       }
       impactBuilder.registerTypeUse(
           new TypeUse.instantiation(backendClasses.typeImplementation.rawType));
     }
     lookupMapAnalysis.registerConstantKey(constant);
   }
 
   void computeImpactForInstantiatedConstantType(
       DartType type, WorldImpactBuilder impactBuilder) {
     DartType instantiatedType =
-        type.isFunctionType ? coreTypes.functionType : type;
+        type.isFunctionType ? commonElements.functionType : type;
     if (type is InterfaceType) {
       impactBuilder
           .registerTypeUse(new TypeUse.instantiation(instantiatedType));
       if (classNeedsRtiField(type.element)) {
         impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
             helpers.setRuntimeTypeInfo,
             null));
       }
       if (type.element == backendClasses.typeImplementation) {
@@ skipping 19 matching lines @@
 
   WorldImpact _processClass(ClassElement cls, {bool forResolution}) {
     WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     if (!cls.typeVariables.isEmpty) {
       typeVariableHandler.registerClassWithTypeVariables(cls,
           forResolution: forResolution);
     }
 
     // Register any helper that will be needed by the backend.
     if (forResolution) {
-      if (cls == coreClasses.intClass ||
-          cls == coreClasses.doubleClass ||
-          cls == coreClasses.numClass) {
+      if (cls == commonElements.intClass ||
+          cls == commonElements.doubleClass ||
+          cls == commonElements.numClass) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.numClasses);
-      } else if (cls == coreClasses.listClass ||
-          cls == coreClasses.stringClass) {
+      } else if (cls == commonElements.listClass ||
+          cls == commonElements.stringClass) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.listOrStringClasses);
-      } else if (cls == coreClasses.functionClass) {
+      } else if (cls == commonElements.functionClass) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.functionClass);
-      } else if (cls == coreClasses.mapClass) {
+      } else if (cls == commonElements.mapClass) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.mapClass);
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         rti.registerRtiDependency(helpers.mapLiteralClass, cls);
       } else if (cls == helpers.boundClosureClass) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.boundClosureClass);
       } else if (isNativeOrExtendsNative(cls)) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.nativeOrExtendsClass);
       } else if (cls == helpers.mapLiteralClass) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.mapLiteralClass);
       }
     }
     if (cls == helpers.closureClass) {
       impactTransformer.registerBackendImpact(
           impactBuilder, impacts.closureClass);
     }
-    if (cls == coreClasses.stringClass || cls == helpers.jsStringClass) {
+    if (cls == commonElements.stringClass || cls == helpers.jsStringClass) {
       addInterceptors(helpers.jsStringClass, impactBuilder,
           forResolution: forResolution);
-    } else if (cls == coreClasses.listClass ||
+    } else if (cls == commonElements.listClass ||
         cls == helpers.jsArrayClass ||
         cls == helpers.jsFixedArrayClass ||
         cls == helpers.jsExtendableArrayClass ||
         cls == helpers.jsUnmodifiableArrayClass) {
       addInterceptors(helpers.jsArrayClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsMutableArrayClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsFixedArrayClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsExtendableArrayClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsUnmodifiableArrayClass, impactBuilder,
           forResolution: forResolution);
       if (forResolution) {
         impactTransformer.registerBackendImpact(
             impactBuilder, impacts.listClasses);
       }
-    } else if (cls == coreClasses.intClass || cls == helpers.jsIntClass) {
+    } else if (cls == commonElements.intClass || cls == helpers.jsIntClass) {
       addInterceptors(helpers.jsIntClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsPositiveIntClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsUInt32Class, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsUInt31Class, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsNumberClass, impactBuilder,
           forResolution: forResolution);
-    } else if (cls == coreClasses.doubleClass || cls == helpers.jsDoubleClass) {
+    } else if (cls == commonElements.doubleClass ||
+        cls == helpers.jsDoubleClass) {
       addInterceptors(helpers.jsDoubleClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsNumberClass, impactBuilder,
           forResolution: forResolution);
-    } else if (cls == coreClasses.boolClass || cls == helpers.jsBoolClass) {
+    } else if (cls == commonElements.boolClass || cls == helpers.jsBoolClass) {
       addInterceptors(helpers.jsBoolClass, impactBuilder,
           forResolution: forResolution);
-    } else if (cls == coreClasses.nullClass || cls == helpers.jsNullClass) {
+    } else if (cls == commonElements.nullClass || cls == helpers.jsNullClass) {
       addInterceptors(helpers.jsNullClass, impactBuilder,
           forResolution: forResolution);
-    } else if (cls == coreClasses.numClass || cls == helpers.jsNumberClass) {
+    } else if (cls == commonElements.numClass || cls == helpers.jsNumberClass) {
       addInterceptors(helpers.jsIntClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsPositiveIntClass, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsUInt32Class, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsUInt31Class, impactBuilder,
           forResolution: forResolution);
       addInterceptors(helpers.jsDoubleClass, impactBuilder,
           forResolution: forResolution);
@@ skipping 285 matching lines @@
     return new native.NativeCodegenEnqueuer(compiler, emitter);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
     if (isJsInterop(element)) {
       return helpers.jsJavaScriptObjectClass;
     }
     // Native classes inherit from Interceptor.
     return isNative(element)
         ? helpers.jsInterceptorClass
-        : coreClasses.objectClass;
+        : commonElements.objectClass;
   }
 
   /**
    * Unit test hook that returns code of an element as a String.
    *
    * Invariant: [element] must be a declaration element.
    */
   String getGeneratedCode(Element element) {
     assert(invariant(element, element.isDeclaration));
     return jsAst.prettyPrint(generatedCode[element], compiler);
@@ skipping 93 matching lines @@
     // TODO(13955), TODO(9731).  The test for non-primitive types should use an
     // interceptor.  The interceptor should be an argument to HTypeConversion so
     // that it can be optimized by standard interceptor optimizations.
     nativeCheck = true;
 
     if (type.isVoid) {
       assert(!typeCast); // Cannot cast to void.
       if (nativeCheckOnly) return null;
       return 'voidTypeCheck';
     } else if (element == helpers.jsStringClass ||
-        element == coreClasses.stringClass) {
+        element == commonElements.stringClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'stringTypeCast' : 'stringTypeCheck';
     } else if (element == helpers.jsDoubleClass ||
-        element == coreClasses.doubleClass) {
+        element == commonElements.doubleClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'doubleTypeCast' : 'doubleTypeCheck';
     } else if (element == helpers.jsNumberClass ||
-        element == coreClasses.numClass) {
+        element == commonElements.numClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'numTypeCast' : 'numTypeCheck';
     } else if (element == helpers.jsBoolClass ||
-        element == coreClasses.boolClass) {
+        element == commonElements.boolClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'boolTypeCast' : 'boolTypeCheck';
     } else if (element == helpers.jsIntClass ||
-        element == coreClasses.intClass ||
+        element == commonElements.intClass ||
         element == helpers.jsUInt32Class ||
         element == helpers.jsUInt31Class ||
         element == helpers.jsPositiveIntClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'intTypeCast' : 'intTypeCheck';
     } else if (Elements.isNumberOrStringSupertype(element, commonElements)) {
       if (nativeCheck) {
         return typeCast
             ? 'numberOrStringSuperNativeTypeCast'
             : 'numberOrStringSuperNativeTypeCheck';
       } else {
         return typeCast
             ? 'numberOrStringSuperTypeCast'
             : 'numberOrStringSuperTypeCheck';
       }
     } else if (Elements.isStringOnlySupertype(element, commonElements)) {
       if (nativeCheck) {
         return typeCast
             ? 'stringSuperNativeTypeCast'
             : 'stringSuperNativeTypeCheck';
       } else {
         return typeCast ? 'stringSuperTypeCast' : 'stringSuperTypeCheck';
       }
-    } else if ((element == coreClasses.listClass ||
+    } else if ((element == commonElements.listClass ||
             element == helpers.jsArrayClass) &&
         type.treatAsRaw) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'listTypeCast' : 'listTypeCheck';
     } else {
       if (Elements.isListSupertype(element, commonElements)) {
         if (nativeCheck) {
           return typeCast
               ? 'listSuperNativeTypeCast'
               : 'listSuperNativeTypeCheck';
@@ skipping 32 matching lines @@
     impactTransformer.registerBackendImpact(
         impactBuilder, new BackendImpact(globalUses: staticUses));
   }
 
   /**
    * Returns [:true:] if the checking of [type] is performed directly on the
    * object and not on an interceptor.
    */
   bool hasDirectCheckFor(DartType type) {
     Element element = type.element;
-    return element == coreClasses.stringClass ||
-        element == coreClasses.boolClass ||
-        element == coreClasses.numClass ||
-        element == coreClasses.intClass ||
-        element == coreClasses.doubleClass ||
+    return element == commonElements.stringClass ||
+        element == commonElements.boolClass ||
+        element == commonElements.numClass ||
+        element == commonElements.intClass ||
+        element == commonElements.doubleClass ||
         element == helpers.jsArrayClass ||
         element == helpers.jsMutableArrayClass ||
         element == helpers.jsExtendableArrayClass ||
         element == helpers.jsFixedArrayClass ||
         element == helpers.jsUnmodifiableArrayClass;
   }
 
   bool mayGenerateInstanceofCheck(DartType type) {
     // We can use an instanceof check for raw types that have no subclass that
     // is mixed-in or in an implements clause.
@@ skipping 155 matching lines @@
   }
 
   Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     if (!loadedLibraries.containsLibrary(Uris.dart_core)) {
       return new Future.value();
     }
 
     helpers.onLibrariesLoaded(loadedLibraries);
 
     implementationClasses = <ClassElement, ClassElement>{};
-    implementationClasses[coreClasses.intClass] = helpers.jsIntClass;
-    implementationClasses[coreClasses.boolClass] = helpers.jsBoolClass;
-    implementationClasses[coreClasses.numClass] = helpers.jsNumberClass;
-    implementationClasses[coreClasses.doubleClass] = helpers.jsDoubleClass;
-    implementationClasses[coreClasses.stringClass] = helpers.jsStringClass;
-    implementationClasses[coreClasses.listClass] = helpers.jsArrayClass;
-    implementationClasses[coreClasses.nullClass] = helpers.jsNullClass;
+    implementationClasses[commonElements.intClass] = helpers.jsIntClass;
+    implementationClasses[commonElements.boolClass] = helpers.jsBoolClass;
+    implementationClasses[commonElements.numClass] = helpers.jsNumberClass;
+    implementationClasses[commonElements.doubleClass] = helpers.jsDoubleClass;
+    implementationClasses[commonElements.stringClass] = helpers.jsStringClass;
+    implementationClasses[commonElements.listClass] = helpers.jsArrayClass;
+    implementationClasses[commonElements.nullClass] = helpers.jsNullClass;
 
     // These methods are overwritten with generated versions.
     inlineCache.markAsNonInlinable(helpers.getInterceptorMethod,
         insideLoop: true);
 
     specialOperatorEqClasses
-      ..add(coreClasses.objectClass)
+      ..add(commonElements.objectClass)
       ..add(helpers.jsInterceptorClass)
       ..add(helpers.jsNullClass);
 
     validateInterceptorImplementsAllObjectMethods(helpers.jsInterceptorClass);
     // The null-interceptor must also implement *all* methods.
     validateInterceptorImplementsAllObjectMethods(helpers.jsNullClass);
 
     return new Future.value();
   }
 
@@ skipping 68 matching lines @@
   bool matchesMirrorsMetaTarget(Element element) {
     if (metaTargetsUsed.isEmpty) return false;
     for (MetadataAnnotation metadata in element.metadata) {
       // TODO(kasperl): It would be nice if we didn't have to resolve
       // all metadata but only stuff that potentially would match one
       // of the used meta targets.
       metadata.ensureResolved(resolution);
       ConstantValue value =
           compiler.constants.getConstantValue(metadata.constant);
       if (value == null) continue;
-      DartType type = value.getType(compiler.coreTypes);
+      DartType type = value.getType(compiler.commonElements);
       if (metaTargetsUsed.contains(type.element)) return true;
     }
     return false;
   }
 
   /**
    * Visits all classes and computes whether its members are needed for
    * reflection.
    *
    * We have to precompute this set as we cannot easily answer the need for
@@ skipping 706 matching lines @@
             // TODO(johnniwinther): This should have its own uncatchable error.
             registerBackendImpact(transformed, impacts.throwRuntimeError);
           }
           break;
         case Feature.FALL_THROUGH_ERROR:
           registerBackendImpact(transformed, impacts.fallThroughError);
           break;
         case Feature.FIELD_WITHOUT_INITIALIZER:
         case Feature.LOCAL_WITHOUT_INITIALIZER:
           transformed.registerTypeUse(
-              new TypeUse.instantiation(backend.coreTypes.nullType));
+              new TypeUse.instantiation(backend.commonElements.nullType));
           registerBackendImpact(transformed, impacts.nullLiteral);
           break;
         case Feature.LAZY_FIELD:
           registerBackendImpact(transformed, impacts.lazyField);
           break;
         case Feature.STACK_TRACE_IN_CATCH:
           registerBackendImpact(transformed, impacts.stackTraceInCatch);
           break;
         case Feature.STRING_INTERPOLATION:
           registerBackendImpact(transformed, impacts.stringInterpolation);
@@ skipping 69 matching lines @@
           break;
       }
     }
 
     if (hasAsCast) {
       registerBackendImpact(transformed, impacts.asCheck);
     }
 
     if (hasTypeLiteral) {
       transformed.registerTypeUse(
-          new TypeUse.instantiation(backend.compiler.coreTypes.typeType));
+          new TypeUse.instantiation(backend.compiler.commonElements.typeType));
       registerBackendImpact(transformed, impacts.typeLiteral);
     }
 
     for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
       // TODO(johnniwinther): Use the [isEmpty] property when factory
       // constructors are registered directly.
       if (mapLiteralUse.isConstant) {
         registerBackendImpact(transformed, impacts.constantMapLiteral);
       } else {
         transformed
@@ skipping 374 matching lines @@
   ClassElement get fixedListImplementation => helpers.jsFixedArrayClass;
   ClassElement get growableListImplementation => helpers.jsExtendableArrayClass;
   ClassElement get mapImplementation => helpers.mapLiteralClass;
   ClassElement get constMapImplementation => helpers.constMapLiteralClass;
   ClassElement get typeImplementation => helpers.typeLiteralClass;
   ClassElement get boolImplementation => helpers.jsBoolClass;
   ClassElement get nullImplementation => helpers.jsNullClass;
   ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
   ClassElement get asyncFutureImplementation => helpers.futureImplementation;
   ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
-  ClassElement get functionImplementation => helpers.coreClasses.functionClass;
+  ClassElement get functionImplementation =>
+      helpers.commonElements.functionClass;
   ClassElement get indexableImplementation => helpers.jsIndexableClass;
   ClassElement get mutableIndexableImplementation =>
       helpers.jsMutableIndexableClass;
   ClassElement get indexingBehaviorImplementation =>
       helpers.jsIndexingBehaviorInterface;
   ClassElement get interceptorImplementation => helpers.jsInterceptorClass;
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
-    return classElement == helpers.coreClasses.objectClass ||
+    return classElement == helpers.commonElements.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
 
   @override
   bool isInterceptorClass(ClassElement cls) {
     return helpers.backend.isInterceptorClass(cls);
   }
 
   @override
   bool isNative(Element element) {
     return helpers.backend.isNative(element);
   }
 }