Move remaining helpers to BackendHelpers

pkg/compiler/lib/src/js_backend/codegen/glue.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 code_generator_dependencies;
 
+import '../backend_helpers.dart' show
+    BackendHelpers;
 import '../js_backend.dart';
 
 import '../../common.dart';
 import '../../common/registry.dart' show
     Registry;
 import '../../common/codegen.dart' show
     CodegenRegistry;
 import '../../compiler.dart' show
     Compiler;
 import '../../constants/values.dart';
@@ skipping 15 matching lines @@
 
 /// Encapsulates the dependencies of the function-compiler to the compiler,
 /// backend and emitter.
 // TODO(sigurdm): Should be refactored when we have a better feeling for the
 // interface.
 class Glue {
   final Compiler _compiler;
 
   CodegenEnqueuer get _enqueuer => _compiler.enqueuer.codegen;
 
-  FunctionElement get getInterceptorMethod => _backend.getInterceptorMethod;
+  FunctionElement get getInterceptorMethod => _helpers.getInterceptorMethod;
 
   JavaScriptBackend get _backend => _compiler.backend;
 
+  BackendHelpers get _helpers => _backend.helpers;
+
   CodeEmitterTask get _emitter => _backend.emitter;
 
   Namer get _namer => _backend.namer;
 
   Glue(this._compiler);
 
   ClassWorld get classWorld => _compiler.world;
 
   DiagnosticReporter get reporter => _compiler.reporter;
 
@@ skipping 29 matching lines @@
     return _backend.constants.lazyStatics.contains(element);
   }
 
   String safeVariableName(String name) {
     return _namer.safeVariableName(name);
   }
 
   ClassElement get listClass => _compiler.coreClasses.listClass;
 
   ConstructorElement get mapLiteralConstructor {
-    return _backend.mapLiteralConstructor;
+    return _helpers.mapLiteralConstructor;
   }
 
   ConstructorElement get mapLiteralConstructorEmpty {
-    return _backend.mapLiteralConstructorEmpty;
+    return _helpers.mapLiteralConstructorEmpty;
   }
 
   FunctionElement get identicalFunction => _compiler.identicalFunction;
 
   js.Name invocationName(Selector selector) {
     return _namer.invocationName(selector);
   }
 
   FunctionElement get createInvocationMirrorMethod {
-    return _backend.helpers.createInvocationMirror;
+    return _helpers.createInvocationMirror;
   }
 
   void registerUseInterceptorInCodegen() {
     _backend.registerUseInterceptor(_enqueuer);
   }
 
   bool isInterceptedSelector(Selector selector) {
     return _backend.isInterceptedSelector(selector);
   }
 
   bool isInterceptedMethod(Element element) {
     return _backend.isInterceptedMethod(element);
   }
 
   bool isInterceptorClass(ClassElement element) {
-    return element.isSubclassOf(_backend.jsInterceptorClass);
+    return element.isSubclassOf(_helpers.jsInterceptorClass);
   }
 
   Set<ClassElement> getInterceptedClassesOn(Selector selector) {
     return _backend.getInterceptedClassesOn(selector.name);
   }
 
   Set<ClassElement> get interceptedClasses {
     return _backend.interceptedClasses;
   }
 
@@ skipping 18 matching lines @@
     return _emitter.prototypeAccess(e,
         hasBeenInstantiated: hasBeenInstantiated);
   }
 
   js.Name getInterceptorName(Set<ClassElement> interceptedClasses) {
     return _backend.namer.nameForGetInterceptor(interceptedClasses);
   }
 
   js.Expression getInterceptorLibrary() {
     return new js.VariableUse(
-        _backend.namer.globalObjectFor(_backend.interceptorsLibrary));
+        _backend.namer.globalObjectFor(_helpers.interceptorsLibrary));
   }
 
   FunctionElement getWrapExceptionHelper() {
-    return _backend.helpers.wrapExceptionHelper;
+    return _helpers.wrapExceptionHelper;
   }
 
   FunctionElement getExceptionUnwrapper() {
-    return _backend.helpers.exceptionUnwrapper;
+    return _helpers.exceptionUnwrapper;
   }
 
   FunctionElement getTraceFromException() {
-    return _backend.helpers.traceFromException;
+    return _helpers.traceFromException;
   }
 
   FunctionElement getCreateRuntimeType() {
-    return _backend.helpers.createRuntimeType;
+    return _helpers.createRuntimeType;
   }
 
   FunctionElement getRuntimeTypeToString() {
-    return _backend.helpers.runtimeTypeToString;
+    return _helpers.runtimeTypeToString;
   }
 
   FunctionElement getRuntimeTypeArgument() {
-    return _backend.helpers.getRuntimeTypeArgument;
+    return _helpers.getRuntimeTypeArgument;
   }
 
   FunctionElement getTypeArgumentByIndex() {
-    return _backend.helpers.getTypeArgumentByIndex;
+    return _helpers.getTypeArgumentByIndex;
   }
 
   FunctionElement getAddRuntimeTypeInformation() {
-    return _backend.helpers.setRuntimeTypeInfo;
+    return _helpers.setRuntimeTypeInfo;
   }
 
   /// checkSubtype(value, $isT, typeArgs, $asT)
   FunctionElement getCheckSubtype() {
-    return _backend.helpers.checkSubtype;
+    return _helpers.checkSubtype;
   }
 
   /// subtypeCast(value, $isT, typeArgs, $asT)
   FunctionElement getSubtypeCast() {
-    return _backend.helpers.subtypeCast;
+    return _helpers.subtypeCast;
   }
 
   /// checkSubtypeOfRuntime(value, runtimeType)
   FunctionElement getCheckSubtypeOfRuntimeType() {
-    return _backend.helpers.checkSubtypeOfRuntimeType;
+    return _helpers.checkSubtypeOfRuntimeType;
   }
 
   /// subtypeOfRuntimeTypeCast(value, runtimeType)
   FunctionElement getSubtypeOfRuntimeTypeCast() {
-    return _backend.helpers.subtypeOfRuntimeTypeCast;
+    return _helpers.subtypeOfRuntimeTypeCast;
   }
 
   js.Expression getRuntimeTypeName(ClassElement cls) {
     return js.quoteName(_namer.runtimeTypeName(cls));
   }
 
   int getTypeVariableIndex(TypeVariableType variable) {
     return variable.element.index;
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     ClassWorld classWorld = _compiler.world;
     if (classWorld.isUsedAsMixin(cls)) return true;
 
     Iterable<ClassElement> subclasses = _compiler.world.strictSubclassesOf(cls);
     return subclasses.any((ClassElement subclass) {
       return !_backend.rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   js.Expression generateTypeRepresentation(DartType dartType,
                                            List<js.Expression> arguments,
                                            CodegenRegistry registry) {
     int variableIndex = 0;
     js.Expression representation = _backend.rtiEncoder.getTypeRepresentation(
         dartType,
         (_) => arguments[variableIndex++]);
     assert(variableIndex == arguments.length);
     // Representation contains JavaScript Arrays.
-    registry.registerInstantiatedClass(_backend.jsArrayClass);
+    registry.registerInstantiatedClass(_helpers.jsArrayClass);
     return representation;
   }
 
   void registerIsCheck(DartType type, Registry registry) {
     _enqueuer.registerIsCheck(type);
     _backend.registerIsCheckForCodegen(type, _enqueuer, registry);
   }
 
   js.Name getTypeTestTag(DartType type) {
     return _backend.namer.operatorIsType(type);
   }
 
   js.Name getTypeSubstitutionTag(ClassElement element) {
     return _backend.namer.substitutionName(element);
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement element) {
     return _backend.operatorEqHandlesNullArgument(element);
   }
 
   bool hasStrictSubtype(ClassElement element) {
     return _compiler.world.hasAnyStrictSubtype(element);
   }
 
-  ClassElement get jsFixedArrayClass => _backend.jsFixedArrayClass;
-  ClassElement get jsExtendableArrayClass => _backend.jsExtendableArrayClass;
+  ClassElement get jsFixedArrayClass => _helpers.jsFixedArrayClass;
+  ClassElement get jsExtendableArrayClass => _helpers.jsExtendableArrayClass;
   ClassElement get jsUnmodifiableArrayClass =>
-      _backend.jsUnmodifiableArrayClass;
-  ClassElement get jsMutableArrayClass => _backend.jsMutableArrayClass;
+      _helpers.jsUnmodifiableArrayClass;
+  ClassElement get jsMutableArrayClass => _helpers.jsMutableArrayClass;
 
   bool isStringClass(ClassElement classElement) =>
-      classElement == _backend.jsStringClass ||
+      classElement == _helpers.jsStringClass ||
       classElement == _compiler.coreClasses.stringClass;
 
   bool isBoolClass(ClassElement classElement) =>
-      classElement == _backend.jsBoolClass ||
+      classElement == _helpers.jsBoolClass ||
       classElement == _compiler.coreClasses.boolClass;
 
   // TODO(sra): Should this be part of CodegenRegistry?
   void registerNativeBehavior(NativeBehavior nativeBehavior, node) {
     if (nativeBehavior == null) return;
     _enqueuer.nativeEnqueuer.registerNativeBehavior(nativeBehavior, node);
   }
 
   ConstantValue getDefaultParameterValue(ParameterElement elem) {
     return _backend.constants.getConstantValueForVariable(elem);
   }
 }