Move remaining helpers to BackendHelpers

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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.
 
 part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 439 matching lines @@
         constantHasher = new ConstantCanonicalHasher(compiler),
         functionTypeNamer = new FunctionTypeNamer(compiler) {
     _literalAsyncPrefix = new StringBackedName(asyncPrefix);
     _literalGetterPrefix = new StringBackedName(getterPrefix);
     _literalSetterPrefix = new StringBackedName(setterPrefix);
     _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
   }
 
   JavaScriptBackend get backend => compiler.backend;
 
+  BackendHelpers get helpers => backend.helpers;
+
   DiagnosticReporter get reporter => compiler.reporter;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   String get deferredTypesName => 'deferredTypes';
   String get isolateName => 'Isolate';
   String get isolatePropertiesName => r'$isolateProperties';
   jsAst.Name get noSuchMethodName => invocationName(Selectors.noSuchMethod_);
 
   /**
@@ skipping 31 matching lines @@
         return asName(functionTypeVoidReturnTag);
       case JsGetName.FUNCTION_TYPE_RETURN_TYPE_TAG:
         return asName(functionTypeReturnTypeTag);
       case JsGetName.FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG:
         return asName(functionTypeRequiredParametersTag);
       case JsGetName.FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG:
         return asName(functionTypeOptionalParametersTag);
       case JsGetName.FUNCTION_TYPE_NAMED_PARAMETERS_TAG:
         return asName(functionTypeNamedParametersTag);
       case JsGetName.IS_INDEXABLE_FIELD_NAME:
-        Element cls = backend.findHelper('JavaScriptIndexingBehavior');
-        return operatorIs(cls);
+        return operatorIs(helpers.jsIndexingBehaviorInterface);
       case JsGetName.NULL_CLASS_TYPE_NAME:
         return runtimeTypeName(coreClasses.nullClass);
       case JsGetName.OBJECT_CLASS_TYPE_NAME:
         return runtimeTypeName(coreClasses.objectClass);
       case JsGetName.FUNCTION_CLASS_TYPE_NAME:
         return runtimeTypeName(coreClasses.functionClass);
       default:
         reporter.reportErrorMessage(
           node,
           MessageKind.GENERIC,
@@ skipping 678 matching lines @@
       name = disambiguated;
     } else {
       name = element.name;
     }
     return name;
   }
 
   String suffixForGetInterceptor(Iterable<ClassElement> classes) {
     String abbreviate(ClassElement cls) {
       if (cls == coreClasses.objectClass) return "o";
-      if (cls == backend.jsStringClass) return "s";
-      if (cls == backend.jsArrayClass) return "a";
-      if (cls == backend.jsDoubleClass) return "d";
-      if (cls == backend.jsIntClass) return "i";
-      if (cls == backend.jsNumberClass) return "n";
-      if (cls == backend.jsNullClass) return "u";
-      if (cls == backend.jsBoolClass) return "b";
-      if (cls == backend.jsInterceptorClass) return "I";
+      if (cls == helpers.jsStringClass) return "s";
+      if (cls == helpers.jsArrayClass) return "a";
+      if (cls == helpers.jsDoubleClass) return "d";
+      if (cls == helpers.jsIntClass) return "i";
+      if (cls == helpers.jsNumberClass) return "n";
+      if (cls == helpers.jsNullClass) return "u";
+      if (cls == helpers.jsBoolClass) return "b";
+      if (cls == helpers.jsInterceptorClass) return "I";
       return cls.name;
     }
     List<String> names = classes
         .where((cls) => !backend.isNativeOrExtendsNative(cls))
         .map(abbreviate)
         .toList();
     // There is one dispatch mechanism for all native classes.
     if (classes.any((cls) => backend.isNativeOrExtendsNative(cls))) {
       names.add("x");
     }
     // Sort the names of the classes after abbreviating them to ensure
     // the suffix is stable and predictable for the suggested names.
     names.sort();
     return names.join();
   }
 
   /// Property name used for `getInterceptor` or one of its specializations.
   jsAst.Name nameForGetInterceptor(Iterable<ClassElement> classes) {
-    FunctionElement getInterceptor = backend.getInterceptorMethod;
-    if (classes.contains(backend.jsInterceptorClass)) {
+    FunctionElement getInterceptor = helpers.getInterceptorMethod;
+    if (classes.contains(helpers.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes, we
       // need to go through the generic getInterceptorMethod, since any subclass
       // of the base Interceptor could match.
       // The unspecialized getInterceptor method can also be accessed through
       // its element, so we treat this as a user-space global instead of an
       // internal global.
       return _disambiguateGlobal(getInterceptor);
     }
     String suffix = suffixForGetInterceptor(classes);
     return _disambiguateInternalGlobal("${getInterceptor.name}\$$suffix");
   }
 
   /// Property name used for the one-shot interceptor method for the given
   /// [selector] and return-type specialization.
   jsAst.Name nameForGetOneShotInterceptor(Selector selector,
                                           Iterable<ClassElement> classes) {
     // The one-shot name is a global name derived from the invocation name.  To
     // avoid instability we would like the names to be unique and not clash with
     // other global names.
     jsAst.Name root = invocationName(selector);
 
-    if (classes.contains(backend.jsInterceptorClass)) {
+    if (classes.contains(helpers.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes,
       // this is the most general specialization which uses the generic
       // getInterceptor method.
       // TODO(sra): Find a way to get the simple name when Object is not in the
       // set of classes for most general variant, e.g. "$lt$n" could be "$lt".
       return new CompoundName([root, _literalDollar]);
     } else {
       String suffix = suffixForGetInterceptor(classes);
       return new CompoundName([root, _literalDollar,
                                new StringBackedName(suffix)]);
@@ skipping 89 matching lines @@
         !element.isTypedef &&
         !element.isConstructor &&
         !element.isFunction &&
         !element.isLibrary;
   }
 
   /// Returns [staticStateHolder] or one of [reservedGlobalObjectNames].
   String globalObjectFor(Element element) {
     if (_isPropertyOfStaticStateHolder(element)) return staticStateHolder;
     LibraryElement library = element.library;
-    if (library == backend.interceptorsLibrary) return 'J';
+    if (library == helpers.interceptorsLibrary) return 'J';
     if (library.isInternalLibrary) return 'H';
     if (library.isPlatformLibrary) {
       if ('${library.canonicalUri}' == 'dart:html') return 'W';
       return 'P';
     }
     return userGlobalObjects[
         library.libraryOrScriptName.hashCode % userGlobalObjects.length];
   }
 
   jsAst.Name deriveLazyInitializerName(jsAst.Name name) {
@@ skipping 644 matching lines @@
       }
     }
   }
 }
 
 enum NamingScope {
   global,
   instance,
   constant
 }