Merge CommonElements and 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.
 
 library js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../diagnostics/invariant.dart' show DEBUG_MODE;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as jsAst;
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector, SelectorKind;
 import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import 'package:front_end/src/fasta/scanner/characters.dart';
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld;
 import 'backend.dart';
-import 'backend_helpers.dart';
 import 'constant_system_javascript.dart';
 import 'native_data.dart';
 
 part 'field_naming_mixin.dart';
 part 'frequency_namer.dart';
 part 'minify_namer.dart';
 part 'namer_names.dart';
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
@@ skipping 440 matching lines @@
   jsAst.Name _rtiFieldJsName;
   jsAst.Name get rtiFieldJsName =>
       _rtiFieldJsName ??= new StringBackedName(rtiName);
 
   // Name of property in a class description for the native dispatch metadata.
   final String nativeSpecProperty = '%';
 
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static final RegExp NON_IDENTIFIER_CHAR = new RegExp(r'[^A-Za-z_0-9$]');
 
-  final BackendHelpers _helpers;
   final NativeData _nativeData;
   final ClosedWorld _closedWorld;
   final CodegenWorldBuilder _codegenWorldBuilder;
 
   RuntimeTypesEncoder _rtiEncoder;
   RuntimeTypesEncoder get rtiEncoder {
     assert(invariant(NO_LOCATION_SPANNABLE, _rtiEncoder != null,
         message: "Namer.rtiEncoder has not been set."));
     return _rtiEncoder;
   }
@@ skipping 52 matching lines @@
 
   final Map<String, String> suggestedGlobalNames = <String, String>{};
   final Map<String, String> suggestedInstanceNames = <String, String>{};
 
   /// Used to store unique keys for library names. Keys are not used as names,
   /// nor are they visible in the output. The only serve as an internal
   /// key into maps.
   final Map<LibraryElement, String> _libraryKeys =
       new HashMap<LibraryElement, String>();
 
-  Namer(this._helpers, this._nativeData, this._closedWorld,
-      this._codegenWorldBuilder) {
+  Namer(this._nativeData, this._closedWorld, this._codegenWorldBuilder) {
     _literalAsyncPrefix = new StringBackedName(asyncPrefix);
     _literalGetterPrefix = new StringBackedName(getterPrefix);
     _literalSetterPrefix = new StringBackedName(setterPrefix);
     _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
   }
 
   CommonElements get _commonElements => _closedWorld.commonElements;
 
   String get deferredTypesName => 'deferredTypes';
   String get isolateName => 'Isolate';
@@ skipping 63 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:
-        return operatorIs(_helpers.jsIndexingBehaviorInterface);
+        return operatorIs(_commonElements.jsIndexingBehaviorInterface);
       case JsGetName.NULL_CLASS_TYPE_NAME:
         ClassElement nullClass = _commonElements.nullClass;
         return runtimeTypeName(nullClass);
       case JsGetName.OBJECT_CLASS_TYPE_NAME:
         ClassElement objectClass = _commonElements.objectClass;
         return runtimeTypeName(objectClass);
       case JsGetName.FUNCTION_CLASS_TYPE_NAME:
         ClassElement functionClass = _commonElements.functionClass;
         return runtimeTypeName(functionClass);
       default:
@@ skipping 651 matching lines @@
     for (int c = 0; libraryLongNames.containsValue(disambiguated); c++) {
       disambiguated = "$name$c";
     }
     libraryLongNames[library] = disambiguated;
     return disambiguated;
   }
 
   String suffixForGetInterceptor(Iterable<ClassEntity> classes) {
     String abbreviate(ClassElement cls) {
       if (cls == _commonElements.objectClass) return "o";
-      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";
+      if (cls == _commonElements.jsStringClass) return "s";
+      if (cls == _commonElements.jsArrayClass) return "a";
+      if (cls == _commonElements.jsDoubleClass) return "d";
+      if (cls == _commonElements.jsIntClass) return "i";
+      if (cls == _commonElements.jsNumberClass) return "n";
+      if (cls == _commonElements.jsNullClass) return "u";
+      if (cls == _commonElements.jsBoolClass) return "b";
+      if (cls == _commonElements.jsInterceptorClass) return "I";
       return cls.name;
     }
 
     List<String> names = classes
         .where((cls) => !_nativeData.isNativeOrExtendsNative(cls))
         .map(abbreviate)
         .toList();
     // There is one dispatch mechanism for all native classes.
     if (classes.any((cls) => _nativeData.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<ClassEntity> classes) {
-    MethodElement getInterceptor = _helpers.getInterceptorMethod;
-    if (classes.contains(_helpers.jsInterceptorClass)) {
+    MethodElement getInterceptor = _commonElements.getInterceptorMethod;
+    if (classes.contains(_commonElements.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<ClassEntity> 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(_helpers.jsInterceptorClass)) {
+    if (classes.contains(_commonElements.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 99 matching lines @@
       globalObjectFor(element);
 
   /// Returns [staticStateHolder] or one of [reservedGlobalObjectNames].
   String globalObjectFor(Element element) {
     if (_isPropertyOfStaticStateHolder(element)) return staticStateHolder;
     return globalObjectForLibrary(element.library);
   }
 
   /// Returns the [reservedGlobalObjectNames] for [library].
   String globalObjectForLibrary(LibraryElement library) {
-    if (library == _helpers.interceptorsLibrary) return 'J';
+    if (library == _commonElements.interceptorsLibrary) return 'J';
     if (library.isInternalLibrary) return 'H';
     if (library.isPlatformLibrary) {
       if ('${library.canonicalUri}' == 'dart:html') return 'W';
       return 'P';
     }
     return userGlobalObjects[library.name.hashCode % userGlobalObjects.length];
   }
 
   jsAst.Name deriveLazyInitializerName(jsAst.Name name) {
     // These are not real dart getters, so do not use GetterName;
@@ skipping 682 matching lines @@
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
 
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }