Merge CommonElements and BackendHelpers!

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 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
 import '../common.dart';
 import '../common/backend_api.dart'
@@ skipping 42 matching lines @@
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart';
 import '../universe/use.dart' show ConstantUse, StaticUse;
 import '../universe/world_impact.dart'
     show ImpactStrategy, ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld, ClosedWorldRefiner;
 import 'annotations.dart';
-import 'backend_helpers.dart';
 import 'backend_impact.dart';
 import 'backend_serialization.dart' show JavaScriptBackendSerialization;
 import 'backend_usage.dart';
 import 'checked_mode_helpers.dart';
 import 'codegen_listener.dart';
 import 'constant_handler_javascript.dart';
 import 'custom_elements_analysis.dart';
 import 'enqueuer.dart';
 import 'impact_transformer.dart';
 import 'interceptor_data.dart';
@@ skipping 223 matching lines @@
 }
 
 enum SyntheticConstantKind {
   DUMMY_INTERCEPTOR,
   EMPTY_VALUE,
   TYPEVARIABLE_REFERENCE, // Reference to a type in reflection data.
   NAME
 }
 
 class JavaScriptBackend {
+  static const String JS = 'JS';
+  static const String JS_BUILTIN = 'JS_BUILTIN';
+  static const String JS_EMBEDDED_GLOBAL = 'JS_EMBEDDED_GLOBAL';
+  static const String JS_INTERCEPTOR_CONSTANT = 'JS_INTERCEPTOR_CONSTANT';
+
   final Compiler compiler;
 
   String get patchVersion => emitter.patchVersion;
 
   /// Returns true if the backend supports reflection.
   bool get supportsReflection => emitter.supportsReflection;
 
   final Annotations annotations;
 
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassEntity> get classesRequiredForReflection {
     // TODO(herhut): Clean this up when classes needed for rti are tracked.
-    return [helpers.closureClass, helpers.jsIndexableClass];
+    return [commonElements.closureClass, commonElements.jsIndexableClass];
   }
 
   FunctionCompiler functionCompiler;
 
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
   final Map<MemberElement, jsAst.Expression> generatedCode =
@@ skipping 106 matching lines @@
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
   MirrorsDataImpl _mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   final SuperMemberData superMemberData = new SuperMemberData();
 
   native.NativeResolutionEnqueuer _nativeResolutionEnqueuer;
   native.NativeCodegenEnqueuer _nativeCodegenEnqueuer;
 
-  BackendHelpers helpers;
   BackendImpacts impacts;
 
   /// Common classes used by the backend.
   BackendClasses _backendClasses;
 
   /// Backend access to the front-end.
   final JSFrontendAccess frontend;
 
   Target _target;
 
@@ skipping 32 matching lines @@
       : _rti = new _RuntimeTypes(compiler),
         annotations = new Annotations(compiler),
         this.sourceInformationStrategy = createSourceInformationStrategy(
             generateSourceMap: generateSourceMap,
             useMultiSourceInfo: useMultiSourceInfo,
             useNewSourceInfo: useNewSourceInfo),
         frontend = new JSFrontendAccess(compiler),
         constantCompilerTask = new JavaScriptConstantTask(compiler),
         _nativeDataResolver = new NativeDataResolverImpl(compiler) {
     _target = new JavaScriptBackendTarget(this);
-    helpers = new BackendHelpers(compiler.elementEnvironment, commonElements);
-    impacts = new BackendImpacts(compiler.options, commonElements, helpers);
+    impacts = new BackendImpacts(compiler.options, commonElements);
     _mirrorsData = new MirrorsDataImpl(
-        compiler, compiler.options, commonElements, helpers, constants);
-    _backendUsageBuilder = new BackendUsageBuilderImpl(commonElements, helpers);
-    _checkedModeHelpers = new CheckedModeHelpers(commonElements, helpers);
+        compiler, compiler.options, commonElements, constants);
+    _backendUsageBuilder = new BackendUsageBuilderImpl(commonElements);
+    _checkedModeHelpers = new CheckedModeHelpers(commonElements);
     emitter =
         new CodeEmitterTask(compiler, generateSourceMap, useStartupEmitter);
 
     _typeVariableResolutionAnalysis = new TypeVariableResolutionAnalysis(
         compiler.elementEnvironment, impacts, backendUsageBuilder);
     jsInteropAnalysis = new JsInteropAnalysis(this);
     _mirrorsResolutionAnalysis =
         new MirrorsResolutionAnalysisImpl(this, compiler.resolution);
     lookupMapResolutionAnalysis =
         new LookupMapResolutionAnalysis(reporter, compiler.elementEnvironment);
 
-    noSuchMethodRegistry =
-        new NoSuchMethodRegistry(helpers, new NoSuchMethodResolverImpl());
+    noSuchMethodRegistry = new NoSuchMethodRegistry(
+        commonElements, new NoSuchMethodResolverImpl());
     kernelTask = new KernelTask(compiler);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization = new JavaScriptBackendSerialization(this);
   }
 
   /// The [ConstantSystem] used to interpret compile-time constants for this
   /// backend.
   ConstantSystem get constantSystem => constants.constantSystem;
@@ skipping 157 matching lines @@
         reporter.reportErrorMessage(
             element, MessageKind.JS_INTEROP_INDEX_NOT_SUPPORTED);
       }
       return element;
     }
     return patchResolverTask.measure(() {
       return patchResolverTask.resolveExternalFunction(element);
     });
   }
 
-  bool isForeign(Element element) => element.library == helpers.foreignLibrary;
+  bool isForeign(Element element) =>
+      element.library == commonElements.foreignLibrary;
 
   bool isBackendLibrary(LibraryElement library) {
-    return library == helpers.interceptorsLibrary ||
-        library == helpers.jsHelperLibrary;
+    return library == commonElements.interceptorsLibrary ||
+        library == compiler.commonElements.jsHelperLibrary;
   }
 
   Namer determineNamer(
       ClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder) {
     return compiler.options.enableMinification
         ? compiler.options.useFrequencyNamer
             ? new FrequencyBasedNamer(
-                helpers, nativeData, closedWorld, codegenWorldBuilder)
-            : new MinifyNamer(
-                helpers, nativeData, closedWorld, codegenWorldBuilder)
-        : new Namer(helpers, nativeData, closedWorld, codegenWorldBuilder);
+                nativeData, closedWorld, codegenWorldBuilder)
+            : new MinifyNamer(nativeData, closedWorld, codegenWorldBuilder)
+        : new Namer(nativeData, closedWorld, codegenWorldBuilder);
   }
 
   /// Returns true if global optimizations such as type inferencing can apply to
   /// the field [element].
   ///
   /// One category of elements that do not apply is runtime helpers that the
   /// backend calls, but the optimizations don't see those calls.
   bool canFieldBeUsedForGlobalOptimizations(FieldElement element) {
     return !backendUsage.isFieldUsedByBackend(element) &&
         !mirrorsData.invokedReflectively(element);
   }
 
   /// Returns true if global optimizations such as type inferencing can apply to
   /// the parameter [element].
   ///
   /// One category of elements that do not apply is runtime helpers that the
   /// backend calls, but the optimizations don't see those calls.
   bool canFunctionParametersBeUsedForGlobalOptimizations(
       FunctionElement element) {
     if (element.isLocal) return true;
     MethodElement method = element;
     return !backendUsage.isFunctionUsedByBackend(method) &&
         !mirrorsData.invokedReflectively(method);
   }
 
   /// Maps compile-time classes to their runtime class.  The runtime class is
   /// always a superclass or the class itself.
   ClassElement getRuntimeClass(ClassElement class_) {
-    if (class_.isSubclassOf(helpers.jsIntClass)) return helpers.jsIntClass;
-    if (class_.isSubclassOf(helpers.jsArrayClass)) return helpers.jsArrayClass;
+    if (class_.isSubclassOf(commonElements.jsIntClass))
+      return commonElements.jsIntClass;
+    if (class_.isSubclassOf(commonElements.jsArrayClass))
+      return commonElements.jsArrayClass;
     return class_;
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
     return specialOperatorEqClasses.contains(operatorEqfunction.enclosingClass);
   }
 
   void validateInterceptorImplementsAllObjectMethods(
       ClassElement interceptorClass) {
     if (interceptorClass == null) return;
     interceptorClass.ensureResolved(resolution);
     ClassElement objectClass = commonElements.objectClass;
     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 onResolutionStart(ResolutionEnqueuer enqueuer) {
-    helpers.onResolutionStart();
+    // TODO(johnniwinther): Avoid the compiler.elementEnvironment.getThisType
+    // calls. Currently needed to ensure resolution of the classes for various
+    // queries in native behavior computation, inference and codegen.
+    compiler.elementEnvironment.getThisType(commonElements.jsArrayClass);
+    compiler.elementEnvironment
+        .getThisType(commonElements.jsExtendableArrayClass);
 
-    validateInterceptorImplementsAllObjectMethods(helpers.jsInterceptorClass);
+    validateInterceptorImplementsAllObjectMethods(
+        commonElements.jsInterceptorClass);
     // The null-interceptor must also implement *all* methods.
-    validateInterceptorImplementsAllObjectMethods(helpers.jsNullClass);
+    validateInterceptorImplementsAllObjectMethods(commonElements.jsNullClass);
   }
 
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
     mirrorsDataBuilder.computeMembersNeededForReflection(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
     _backendUsage = backendUsageBuilder.close();
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         compiler.enqueuer.resolution.worldBuilder,
         closedWorld,
         compiler.types,
         commonElements,
-        helpers,
         _backendUsage,
         enableTypeAssertions: compiler.options.enableTypeAssertions);
     _interceptorData = interceptorDataBuilder.onResolutionComplete(closedWorld);
     _oneShotInterceptorData =
-        new OneShotInterceptorData(interceptorData, helpers);
+        new OneShotInterceptorData(interceptorData, commonElements);
     mirrorsResolutionAnalysis.onResolutionComplete();
   }
 
   void onTypeInferenceComplete(GlobalTypeInferenceResults results) {
     noSuchMethodRegistry.onTypeInferenceComplete(results);
   }
 
   /// Called when resolving a call to a foreign function.
   native.NativeBehavior resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
-    if (element.name == BackendHelpers.JS) {
+    if (element.name == JS) {
       return _nativeDataResolver.resolveJsCall(node, resolver);
-    } else if (element.name == BackendHelpers.JS_EMBEDDED_GLOBAL) {
+    } else if (element.name == JS_EMBEDDED_GLOBAL) {
       return _nativeDataResolver.resolveJsEmbeddedGlobalCall(node, resolver);
-    } else if (element.name == BackendHelpers.JS_BUILTIN) {
+    } else if (element.name == JS_BUILTIN) {
       return _nativeDataResolver.resolveJsBuiltinCall(node, resolver);
-    } else if (element.name == BackendHelpers.JS_INTERCEPTOR_CONSTANT) {
+    } else if (element.name == JS_INTERCEPTOR_CONSTANT) {
       // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
       // a class that will be instantiated outside the program by attaching a
       // native class dispatch record referencing the interceptor.
       if (!node.argumentsNode.isEmpty) {
         Node argument = node.argumentsNode.nodes.head;
         ConstantExpression constant = resolver.getConstant(argument);
         if (constant != null && constant.kind == ConstantExpressionKind.TYPE) {
           TypeConstantExpression typeConstant = constant;
           if (typeConstant.type is ResolutionInterfaceType) {
             resolver.registerInstantiatedType(typeConstant.type);
             // No native behavior for this call.
             return null;
           }
         }
       }
       reporter.reportErrorMessage(
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
   ResolutionEnqueuer createResolutionEnqueuer(
       CompilerTask task, Compiler compiler) {
     _nativeBasicData =
         nativeBasicDataBuilder.close(compiler.elementEnvironment);
     _backendClasses = new JavaScriptBackendClasses(
-        compiler.elementEnvironment, helpers, nativeBasicData);
+        compiler.elementEnvironment, commonElements, nativeBasicData);
     _nativeResolutionEnqueuer = new native.NativeResolutionEnqueuer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
-        helpers,
         backendClasses,
         backendUsageBuilder,
         new NativeClassResolverImpl(
-            compiler.resolution, reporter, helpers, nativeBasicData));
+            compiler.resolution, reporter, commonElements, nativeBasicData));
     _nativeData = new NativeDataImpl(nativeBasicData);
     _customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
         compiler.resolution,
         constantSystem,
         commonElements,
         backendClasses,
-        helpers,
         nativeBasicData,
         backendUsageBuilder);
     impactTransformer = new JavaScriptImpactTransformer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
         impacts,
         nativeBasicData,
         _nativeResolutionEnqueuer,
         backendUsageBuilder,
         mirrorsDataBuilder,
         customElementsResolutionAnalysis,
         rtiNeedBuilder);
     _interceptorDataBuilder = new InterceptorDataBuilderImpl(
-        nativeBasicData, helpers, compiler.elementEnvironment, commonElements);
+        nativeBasicData, compiler.elementEnvironment, commonElements);
     return new ResolutionEnqueuer(
         task,
         compiler.options,
         compiler.reporter,
         compiler.options.analyzeOnly && compiler.options.analyzeMain
             ? const DirectEnqueuerStrategy()
             : const TreeShakingEnqueuerStrategy(),
         new ResolutionEnqueuerListener(
             compiler.options,
             compiler.elementEnvironment,
             commonElements,
-            helpers,
             impacts,
             backendClasses,
             nativeBasicData,
             interceptorDataBuilder,
             backendUsageBuilder,
             rtiNeedBuilder,
             mirrorsDataBuilder,
             noSuchMethodRegistry,
             customElementsResolutionAnalysis,
             lookupMapResolutionAnalysis,
             mirrorsResolutionAnalysis,
             typeVariableResolutionAnalysis,
             _nativeResolutionEnqueuer,
             compiler.deferredLoadTask,
             kernelTask),
         new ElementResolutionWorldBuilder(
             this, compiler.resolution, const OpenWorldStrategy()),
         new ResolutionWorkItemBuilder(compiler.resolution));
   }
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(
       CompilerTask task, Compiler compiler, ClosedWorld closedWorld) {
     _typeVariableCodegenAnalysis = new TypeVariableCodegenAnalysis(
-        compiler.elementEnvironment, this, helpers, mirrorsData);
+        compiler.elementEnvironment, this, commonElements, mirrorsData);
     _lookupMapAnalysis = new LookupMapAnalysis(
         reporter,
         constantSystem,
         constants,
         compiler.elementEnvironment,
         commonElements,
-        helpers,
         backendClasses,
         lookupMapResolutionAnalysis);
     _mirrorsCodegenAnalysis = mirrorsResolutionAnalysis.close();
     _customElementsCodegenAnalysis = new CustomElementsCodegenAnalysis(
         compiler.resolution,
         constantSystem,
         commonElements,
         backendClasses,
-        helpers,
         nativeBasicData);
     _nativeCodegenEnqueuer = new native.NativeCodegenEnqueuer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
-        helpers,
         backendClasses,
         emitter,
         _nativeResolutionEnqueuer,
         nativeData);
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
             nativeBasicData, closedWorld, constants, const TypeMaskStrategy()),
         new CodegenWorkItemBuilder(this, compiler.options),
         new CodegenEnqueuerListener(
             compiler.elementEnvironment,
             commonElements,
-            helpers,
             impacts,
             backendClasses,
             backendUsage,
             rtiNeed,
             customElementsCodegenAnalysis,
             typeVariableCodegenAnalysis,
             lookupMapAnalysis,
             mirrorsCodegenAnalysis,
             nativeCodegenEnqueuer));
   }
@@ skipping 11 matching lines @@
           js.escapedString("Compile time error in $element: $messageText");
       generatedCode[element] =
           js("function () { throw new Error(#); }", [messageLiteral]);
       return const CodegenImpact();
     }
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) {
       return const WorldImpact();
     }
     if (element.isConstructor &&
-        element.enclosingClass == helpers.jsNullClass) {
+        element.enclosingClass == commonElements.jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
       return const CodegenImpact();
     }
     if (kind.category == ElementCategory.VARIABLE) {
       FieldElement variableElement = element;
       ConstantExpression constant = variableElement.constant;
       if (constant != null) {
         ConstantValue initialValue = constants.getConstantValue(constant);
         if (initialValue != null) {
           work.registry.worldImpact
@@ skipping 13 matching lines @@
                   constant.isPotential,
               message: "Constant expression without value: "
                   "${constant.toStructuredText()}."));
         }
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         work.registry.worldImpact.registerStaticUse(new StaticUse.staticInvoke(
-            helpers.cyclicThrowHelper, CallStructure.ONE_ARG));
+            commonElements.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
     }
 
     jsAst.Fun function = functionCompiler.compile(work, _closedWorld);
     if (function.sourceInformation == null) {
       function = function.withSourceInformation(
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
     WorldImpact worldImpact = _codegenImpactTransformer
         .transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
 
   // TODO(johnniwinther): Remove this. It is now only used for testing.
   @deprecated
   native.NativeEnqueuer get nativeResolutionEnqueuer =>
       _nativeResolutionEnqueuer;
 
   native.NativeEnqueuer get nativeCodegenEnqueuer => _nativeCodegenEnqueuer;
 
   ClassElement defaultSuperclass(ClassElement element) {
     if (nativeBasicData.isJsInteropClass(element)) {
-      return helpers.jsJavaScriptObjectClass;
+      return commonElements.jsJavaScriptObjectClass;
     }
     // Native classes inherit from Interceptor.
     return nativeBasicData.isNativeClass(element)
-        ? helpers.jsInterceptorClass
+        ? commonElements.jsInterceptorClass
         : 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));
@@ skipping 46 matching lines @@
    * Returns [:true:] if the checking of [type] is performed directly on the
    * object and not on an interceptor.
    */
   bool hasDirectCheckFor(ResolutionDartType type) {
     Element element = type.element;
     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;
+        element == commonElements.jsArrayClass ||
+        element == commonElements.jsMutableArrayClass ||
+        element == commonElements.jsExtendableArrayClass ||
+        element == commonElements.jsFixedArrayClass ||
+        element == commonElements.jsUnmodifiableArrayClass;
   }
 
   /// This method is called immediately after the [library] and its parts have
   /// been loaded.
   void setAnnotations(LibraryElement library) {
     if (!compiler.serialization.isDeserialized(library)) {
       if (canLibraryUseNative(library)) {
         library.forEachLocalMember((Element element) {
           if (element.isClass) {
             checkNativeAnnotation(compiler, element, nativeBasicDataBuilder);
           }
         });
       }
       checkJsInteropClassAnnotations(compiler, library, nativeBasicDataBuilder);
     }
     Uri uri = library.canonicalUri;
     if (uri == Uris.dart_html) {
       htmlLibraryIsLoaded = true;
     } else if (uri == LookupMapResolutionAnalysis.PACKAGE_LOOKUP_MAP) {
       lookupMapResolutionAnalysis.init(library);
     }
     annotations.onLibraryLoaded(library);
   }
 
   /// This method is called when all new libraries loaded through
   /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
   /// have been computed.
   void onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     if (loadedLibraries.containsLibrary(Uris.dart_core)) {
-      helpers.onLibrariesLoaded(loadedLibraries);
+      assert(loadedLibraries.containsLibrary(Uris.dart_core));
+      assert(loadedLibraries.containsLibrary(Uris.dart__interceptors));
+      assert(loadedLibraries.containsLibrary(Uris.dart__js_helper));
 
       // These methods are overwritten with generated versions.
-      inlineCache.markAsNonInlinable(helpers.getInterceptorMethod,
+      inlineCache.markAsNonInlinable(commonElements.getInterceptorMethod,
           insideLoop: true);
 
       specialOperatorEqClasses
         ..add(commonElements.objectClass)
-        ..add(helpers.jsInterceptorClass)
-        ..add(helpers.jsNullClass);
+        ..add(commonElements.jsInterceptorClass)
+        ..add(commonElements.jsNullClass);
     }
   }
 
   jsAst.Call generateIsJsIndexableCall(
       jsAst.Expression use1, jsAst.Expression use2) {
     String dispatchPropertyName = embeddedNames.DISPATCH_PROPERTY_NAME;
     jsAst.Expression dispatchProperty =
         emitter.generateEmbeddedGlobalAccess(dispatchPropertyName);
 
     // We pass the dispatch property record to the isJsIndexable
     // helper rather than reading it inside the helper to increase the
     // chance of making the dispatch record access monomorphic.
     jsAst.PropertyAccess record =
         new jsAst.PropertyAccess(use2, dispatchProperty);
 
     List<jsAst.Expression> arguments = <jsAst.Expression>[use1, record];
-    MethodElement helper = helpers.isJsIndexable;
+    MethodElement helper = commonElements.isJsIndexable;
     jsAst.Expression helperExpression = emitter.staticFunctionAccess(helper);
     return new jsAst.Call(helperExpression, arguments);
   }
 
   /// Called after the queue is closed. [onQueueEmpty] may be called multiple
   /// times, but [onQueueClosed] is only called once.
   void onQueueClosed() {
     jsInteropAnalysis.onQueueClosed();
   }
 
@@ skipping 11 matching lines @@
   }
 
   /// Called when the compiler starts running the codegen enqueuer. The
   /// [WorldImpact] of enabled backend features is returned.
   WorldImpact onCodegenStart(
       ClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder) {
     _closedWorld = closedWorld;
     _namer = determineNamer(closedWorld, codegenWorldBuilder);
     tracer = new Tracer(closedWorld, namer, compiler);
     emitter.createEmitter(namer, closedWorld);
-    _rtiEncoder =
-        _namer.rtiEncoder = new _RuntimeTypesEncoder(namer, emitter, helpers);
+    _rtiEncoder = _namer.rtiEncoder =
+        new _RuntimeTypesEncoder(namer, emitter, commonElements);
     _codegenImpactTransformer = new CodegenImpactTransformer(
         compiler.options,
         compiler.elementEnvironment,
-        helpers,
+        commonElements,
         impacts,
         checkedModeHelpers,
         nativeData,
         backendUsage,
         rtiNeed,
         nativeCodegenEnqueuer,
         namer,
         oneShotInterceptorData,
         lookupMapAnalysis,
         rtiChecksBuilder);
     return const WorldImpact();
   }
 
   /// Called when code generation has been completed.
   void onCodegenEnd() {
     sourceInformationStrategy.onComplete();
     tracer.close();
   }
 
   // Does this element belong in the output
   bool shouldOutput(Element element) => true;
 
   /// Returns `true` if the `native` pseudo keyword is supported for [library].
   bool canLibraryUseNative(LibraryElement library) {
     return native.maybeEnableNative(compiler, library);
   }
 
   bool isTargetSpecificLibrary(LibraryElement library) {
     Uri canonicalUri = library.canonicalUri;
-    if (canonicalUri == BackendHelpers.DART_JS_HELPER ||
-        canonicalUri == BackendHelpers.DART_INTERCEPTORS) {
+    if (canonicalUri == Uris.dart__js_helper ||
+        canonicalUri == Uris.dart__interceptors) {
       return true;
     }
     return false;
   }
 
   /// Process backend specific annotations.
   void processAnnotations(
       Element element, ClosedWorldRefiner closedWorldRefiner) {
     if (element.isMalformed) {
       // Elements that are marked as malformed during parsing or resolution
@@ skipping 14 matching lines @@
     bool hasForceInline = false;
     bool hasNoThrows = false;
     bool hasNoSideEffects = false;
     for (MetadataAnnotation metadata in element.implementation.metadata) {
       metadata.ensureResolved(resolution);
       ConstantValue constantValue =
           compiler.constants.getConstantValue(metadata.constant);
       if (!constantValue.isConstructedObject) continue;
       ObjectConstantValue value = constantValue;
       ClassElement cls = value.type.element;
-      if (cls == helpers.forceInlineClass) {
+      if (cls == commonElements.forceInlineClass) {
         hasForceInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
               element, MessageKind.GENERIC, {'text': "Must inline"});
         }
         inlineCache.markAsMustInline(element);
-      } else if (cls == helpers.noInlineClass) {
+      } else if (cls == commonElements.noInlineClass) {
         hasNoInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
               element, MessageKind.GENERIC, {'text': "Cannot inline"});
         }
         inlineCache.markAsNonInlinable(element);
-      } else if (cls == helpers.noThrowsClass) {
+      } else if (cls == commonElements.noThrowsClass) {
         hasNoThrows = true;
         if (!Elements.isStaticOrTopLevelFunction(element) &&
             !element.isFactoryConstructor) {
           reporter.internalError(
               element,
               "@NoThrows() is currently limited to top-level"
               " or static functions and factory constructors.");
         }
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
               element, MessageKind.GENERIC, {'text': "Cannot throw"});
         }
         closedWorldRefiner.registerCannotThrow(element);
-      } else if (cls == helpers.noSideEffectsClass) {
+      } else if (cls == commonElements.noSideEffectsClass) {
         hasNoSideEffects = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
               element, MessageKind.GENERIC, {'text': "Has no side effects"});
         }
         closedWorldRefiner.registerSideEffectsFree(element);
       }
     }
     if (hasForceInline && hasNoInline) {
       reporter.internalError(
           element, "@ForceInline() must not be used with @NoInline.");
     }
     if (hasNoThrows && !hasNoInline) {
       reporter.internalError(
           element, "@NoThrows() should always be combined with @NoInline.");
     }
     if (hasNoSideEffects && !hasNoInline) {
       reporter.internalError(element,
           "@NoSideEffects() should always be combined with @NoInline.");
     }
   }
 
-  MethodElement helperForBadMain() => helpers.badMain;
+  MethodElement helperForBadMain() => commonElements.badMain;
 
-  MethodElement helperForMissingMain() => helpers.missingMain;
+  MethodElement helperForMissingMain() => commonElements.missingMain;
 
-  MethodElement helperForMainArity() => helpers.mainHasTooManyParameters;
+  MethodElement helperForMainArity() => commonElements.mainHasTooManyParameters;
 
   /// Returns the filename for the output-unit named [name].
   ///
   /// The filename is of the form "<main output file>_<name>.part.js".
   /// If [addExtension] is false, the ".part.js" suffix is left out.
   String deferredPartFileName(String name, {bool addExtension: true}) {
     assert(name != "");
     String outPath = compiler.options.outputUri != null
         ? compiler.options.outputUri.path
         : "out";
@@ skipping 10 matching lines @@
   /// supported by the backend.
   bool enableCodegenWithErrorsIfSupported(Spannable node) => true;
 
   jsAst.Expression rewriteAsync(
       FunctionElement element, jsAst.Expression code) {
     AsyncRewriterBase rewriter = null;
     jsAst.Name name = namer.methodPropertyName(element);
     switch (element.asyncMarker) {
       case AsyncMarker.ASYNC:
         rewriter = new AsyncRewriter(reporter, element,
-            asyncHelper: emitter.staticFunctionAccess(helpers.asyncHelper),
-            wrapBody: emitter.staticFunctionAccess(helpers.wrapBody),
-            newCompleter:
-                emitter.staticFunctionAccess(helpers.syncCompleterConstructor),
+            asyncHelper:
+                emitter.staticFunctionAccess(commonElements.asyncHelper),
+            wrapBody: emitter.staticFunctionAccess(commonElements.wrapBody),
+            newCompleter: emitter
+                .staticFunctionAccess(commonElements.syncCompleterConstructor),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       case AsyncMarker.SYNC_STAR:
         rewriter = new SyncStarRewriter(reporter, element,
             endOfIteration:
-                emitter.staticFunctionAccess(helpers.endOfIteration),
-            newIterable: emitter
-                .staticFunctionAccess(helpers.syncStarIterableConstructor),
+                emitter.staticFunctionAccess(commonElements.endOfIteration),
+            newIterable: emitter.staticFunctionAccess(
+                commonElements.syncStarIterableConstructor),
             yieldStarExpression:
-                emitter.staticFunctionAccess(helpers.yieldStar),
-            uncaughtErrorExpression:
-                emitter.staticFunctionAccess(helpers.syncStarUncaughtError),
+                emitter.staticFunctionAccess(commonElements.yieldStar),
+            uncaughtErrorExpression: emitter
+                .staticFunctionAccess(commonElements.syncStarUncaughtError),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       case AsyncMarker.ASYNC_STAR:
         rewriter = new AsyncStarRewriter(reporter, element,
             asyncStarHelper:
-                emitter.staticFunctionAccess(helpers.asyncStarHelper),
+                emitter.staticFunctionAccess(commonElements.asyncStarHelper),
             streamOfController:
-                emitter.staticFunctionAccess(helpers.streamOfController),
-            wrapBody: emitter.staticFunctionAccess(helpers.wrapBody),
-            newController: emitter
-                .staticFunctionAccess(helpers.asyncStarControllerConstructor),
+                emitter.staticFunctionAccess(commonElements.streamOfController),
+            wrapBody: emitter.staticFunctionAccess(commonElements.wrapBody),
+            newController: emitter.staticFunctionAccess(
+                commonElements.asyncStarControllerConstructor),
             safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
-            yieldExpression: emitter.staticFunctionAccess(helpers.yieldSingle),
+            yieldExpression:
+                emitter.staticFunctionAccess(commonElements.yieldSingle),
             yieldStarExpression:
-                emitter.staticFunctionAccess(helpers.yieldStar),
+                emitter.staticFunctionAccess(commonElements.yieldStar),
             bodyName: namer.deriveAsyncBodyName(name));
         break;
       default:
         assert(element.asyncMarker == AsyncMarker.SYNC);
         return code;
     }
     return rewriter.rewrite(code);
   }
 
   /// Creates an impact strategy to use for compilation.
@@ skipping 62 matching lines @@
   @override
   void onImpactUsed(ImpactUseCase impactUse) {
     if (impactUse == DeferredLoadTask.IMPACT_USE && !supportSerialization) {
       // TODO(johnniwinther): Allow emptying when serialization has been
       // performed.
       resolution.emptyCache();
     }
   }
 }
 
+// TODO(efortuna): Merge with commonElements.
 class JavaScriptBackendClasses implements BackendClasses {
   final ElementEnvironment _env;
-  final BackendHelpers helpers;
+  final CommonElements _commonElements;
   final NativeBasicData _nativeData;
 
-  JavaScriptBackendClasses(this._env, this.helpers, this._nativeData);
+  JavaScriptBackendClasses(this._env, this._commonElements, this._nativeData);
 
-  ClassEntity get intClass => helpers.jsIntClass;
-  ClassEntity get uint32Class => helpers.jsUInt32Class;
-  ClassEntity get uint31Class => helpers.jsUInt31Class;
-  ClassEntity get positiveIntClass => helpers.jsPositiveIntClass;
-  ClassEntity get doubleClass => helpers.jsDoubleClass;
-  ClassEntity get numClass => helpers.jsNumberClass;
-  ClassEntity get stringClass => helpers.jsStringClass;
-  ClassEntity get listClass => helpers.jsArrayClass;
-  ClassEntity get mutableListClass => helpers.jsMutableArrayClass;
-  ClassEntity get constListClass => helpers.jsUnmodifiableArrayClass;
-  ClassEntity get fixedListClass => helpers.jsFixedArrayClass;
-  ClassEntity get growableListClass => helpers.jsExtendableArrayClass;
-  ClassEntity get mapClass => helpers.mapLiteralClass;
-  ClassEntity get constMapClass => helpers.constMapLiteralClass;
-  ClassEntity get typeClass => helpers.typeLiteralClass;
+  ClassEntity get intClass => _commonElements.jsIntClass;
+  ClassEntity get uint32Class => _commonElements.jsUInt32Class;
+  ClassEntity get uint31Class => _commonElements.jsUInt31Class;
+  ClassEntity get positiveIntClass => _commonElements.jsPositiveIntClass;
+  ClassEntity get doubleClass => _commonElements.jsDoubleClass;
+  ClassEntity get numClass => _commonElements.jsNumberClass;
+  ClassEntity get stringClass => _commonElements.jsStringClass;
+  ClassEntity get listClass => _commonElements.jsArrayClass;
+  ClassEntity get mutableListClass => _commonElements.jsMutableArrayClass;
+  ClassEntity get constListClass => _commonElements.jsUnmodifiableArrayClass;
+  ClassEntity get fixedListClass => _commonElements.jsFixedArrayClass;
+  ClassEntity get growableListClass => _commonElements.jsExtendableArrayClass;
+  ClassEntity get mapClass => _commonElements.mapLiteralClass;
+  ClassEntity get constMapClass => _commonElements.constMapLiteralClass;
+  ClassEntity get typeClass => _commonElements.typeLiteralClass;
   InterfaceType get typeType => _env.getRawType(typeClass);
 
-  ClassEntity get boolClass => helpers.jsBoolClass;
-  ClassEntity get nullClass => helpers.jsNullClass;
-  ClassEntity get syncStarIterableClass => helpers.syncStarIterable;
-  ClassEntity get asyncFutureClass => helpers.futureImplementation;
-  ClassEntity get asyncStarStreamClass => helpers.controllerStream;
-  ClassEntity get functionClass => helpers.commonElements.functionClass;
-  ClassEntity get indexableClass => helpers.jsIndexableClass;
-  ClassEntity get mutableIndexableClass => helpers.jsMutableIndexableClass;
-  ClassEntity get indexingBehaviorClass => helpers.jsIndexingBehaviorInterface;
-  ClassEntity get interceptorClass => helpers.jsInterceptorClass;
+  ClassEntity get boolClass => _commonElements.jsBoolClass;
+  ClassEntity get nullClass => _commonElements.jsNullClass;
+  ClassEntity get syncStarIterableClass => _commonElements.syncStarIterable;
+  ClassEntity get asyncFutureClass => _commonElements.futureImplementation;
+  ClassEntity get asyncStarStreamClass => _commonElements.controllerStream;
+  ClassEntity get functionClass => _commonElements.functionClass;
+  ClassEntity get indexableClass => _commonElements.jsIndexableClass;
+  ClassEntity get mutableIndexableClass =>
+      _commonElements.jsMutableIndexableClass;
+  ClassEntity get indexingBehaviorClass =>
+      _commonElements.jsIndexingBehaviorInterface;
+  ClassEntity get interceptorClass => _commonElements.jsInterceptorClass;
 
   bool isDefaultEqualityImplementation(MemberEntity element) {
     assert(element.name == '==');
     ClassEntity classElement = element.enclosingClass;
-    return classElement == helpers.commonElements.objectClass ||
-        classElement == helpers.jsInterceptorClass ||
-        classElement == helpers.jsNullClass;
+    return classElement == _commonElements.objectClass ||
+        classElement == _commonElements.jsInterceptorClass ||
+        classElement == _commonElements.jsNullClass;
   }
 
   @override
   bool isNativeClass(ClassEntity element) {
     return _nativeData.isNativeClass(element);
   }
 
   InterfaceType getConstantMapTypeFor(InterfaceType sourceType,
       {bool hasProtoKey: false, bool onlyStringKeys: false}) {
     ClassEntity classElement = onlyStringKeys
         ? (hasProtoKey
-            ? helpers.constantProtoMapClass
-            : helpers.constantStringMapClass)
-        : helpers.generalConstantMapClass;
+            ? _commonElements.constantProtoMapClass
+            : _commonElements.constantStringMapClass)
+        : _commonElements.generalConstantMapClass;
     List<DartType> typeArgument = sourceType.typeArguments;
     if (sourceType.treatAsRaw) {
       return _env.getRawType(classElement);
     } else {
       return _env.createInterfaceType(classElement, typeArgument);
     }
   }
 
   @override
-  FieldEntity get symbolField => helpers.symbolImplementationField;
+  FieldEntity get symbolField => _commonElements.symbolImplementationField;
 
   @override
   InterfaceType get symbolType {
-    return _env.getRawType(helpers.symbolImplementationClass);
+    return _env.getRawType(_commonElements.symbolImplementationClass);
   }
 }
 
 class JavaScriptBackendTarget extends Target {
   final JavaScriptBackend _backend;
 
   JavaScriptBackendTarget(this._backend);
 
   @override
   bool isTargetSpecificLibrary(LibraryElement element) {
@@ skipping 11 matching lines @@
   }
 
   @override
   dynamic resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
     return _backend.resolveForeignCall(node, element, callStructure, resolver);
   }
 
   @override
   bool isDefaultNoSuchMethod(MethodElement element) {
-    return _backend.helpers.isDefaultNoSuchMethodImplementation(element);
+    return _backend.commonElements.isDefaultNoSuchMethodImplementation(element);
   }
 
   @override
   ClassElement defaultSuperclass(ClassElement element) {
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeBasicData.isNativeClass(element);
@@ skipping 19 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }