Add NativeClassData/NativeClassDataBuilder

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 '../js/js.dart' show js;
 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.
  *
  * Names are generated through three stages:
@@ skipping 435 matching lines @@
 
   jsAst.Name _rtiFieldName;
   jsAst.Name get rtiFieldName => _rtiFieldName ??= new StringBackedName(r'$ti');
 
   // 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 JavaScriptBackend backend;
-  final ClosedWorld closedWorld;
-  final CodegenWorldBuilder codegenWorldBuilder;
+  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;
   }
 
   void set rtiEncoder(RuntimeTypesEncoder value) {
     assert(invariant(NO_LOCATION_SPANNABLE, _rtiEncoder == null,
@@ skipping 49 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(JavaScriptBackend backend, this.closedWorld,
-      CodegenWorldBuilder codegenWorldBuilder)
-      : this.backend = backend,
-        this.codegenWorldBuilder = codegenWorldBuilder {
+  Namer(this._helpers, this._nativeData, this._closedWorld,
+      this._codegenWorldBuilder) {
     _literalAsyncPrefix = new StringBackedName(asyncPrefix);
     _literalGetterPrefix = new StringBackedName(getterPrefix);
     _literalSetterPrefix = new StringBackedName(setterPrefix);
     _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
   }
 
-  BackendHelpers get helpers => backend.helpers;
-
-  DiagnosticReporter get reporter => backend.reporter;
-
-  CommonElements get commonElements => closedWorld.commonElements;
+  CommonElements get _commonElements => _closedWorld.commonElements;
 
   String get deferredTypesName => 'deferredTypes';
   String get isolateName => 'Isolate';
   String get isolatePropertiesName => r'$isolateProperties';
   jsAst.Name get noSuchMethodName => invocationName(Selectors.noSuchMethod_);
 
   /**
    * Some closures must contain their name. The name is stored in
    * [STATIC_CLOSURE_NAME_NAME].
    */
@@ skipping 52 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(_helpers.jsIndexingBehaviorInterface);
       case JsGetName.NULL_CLASS_TYPE_NAME:
-        ClassElement nullClass = commonElements.nullClass;
+        ClassElement nullClass = _commonElements.nullClass;
         return runtimeTypeName(nullClass);
       case JsGetName.OBJECT_CLASS_TYPE_NAME:
-        ClassElement objectClass = commonElements.objectClass;
+        ClassElement objectClass = _commonElements.objectClass;
         return runtimeTypeName(objectClass);
       case JsGetName.FUNCTION_CLASS_TYPE_NAME:
-        ClassElement functionClass = commonElements.functionClass;
+        ClassElement functionClass = _commonElements.functionClass;
         return runtimeTypeName(functionClass);
       default:
-        reporter.reportErrorMessage(node, MessageKind.GENERIC,
-            {'text': 'Error: Namer has no name for "$name".'});
-        return asName('BROKEN');
+        throw new SpannableAssertionFailure(
+            node, 'Error: Namer has no name for "$name".');
     }
   }
 
   /// Return a reference to the given [name].
   ///
   /// This is used to ensure that every use site of a name has a unique node so
   /// that we can properly attribute source information.
   jsAst.Name _newReference(jsAst.Name name) {
     return new _NameReference(name);
   }
@@ skipping 12 matching lines @@
       result = getFreshName(constantScope, longName);
       constantNames[constant] = result;
     }
     return _newReference(result);
   }
 
   /// Proposed name for [constant].
   String constantLongName(ConstantValue constant) {
     String longName = constantLongNames[constant];
     if (longName == null) {
-      _constantHasher ??= new ConstantCanonicalHasher(
-          rtiEncoder, reporter, codegenWorldBuilder);
+      _constantHasher ??=
+          new ConstantCanonicalHasher(rtiEncoder, _codegenWorldBuilder);
       longName = new ConstantNamingVisitor(
-              rtiEncoder, reporter, codegenWorldBuilder, _constantHasher)
+              rtiEncoder, _codegenWorldBuilder, _constantHasher)
           .getName(constant);
       constantLongNames[constant] = longName;
     }
     return longName;
   }
 
   String breakLabelName(LabelDefinition label) {
     return '\$${label.labelName}\$${label.target.nestingLevel}';
   }
 
@@ skipping 64 matching lines @@
 
   /// Annotated name for [method] encoding arity and named parameters.
   jsAst.Name instanceMethodName(MethodElement method) {
     if (method.isGenerativeConstructorBody) {
       return constructorBodyName(method);
     }
     return invocationName(new Selector.fromElement(method));
   }
 
   String _jsNameHelper(Element e) {
-    String jsInteropName = backend.nativeData.getJsInteropName(e);
+    String jsInteropName = _nativeData.getJsInteropName(e);
     if (jsInteropName != null && jsInteropName.isNotEmpty) return jsInteropName;
-    return e.isLibrary
-        ? 'self'
-        : backend.nativeData.getUnescapedJSInteropName(e.name);
+    return e.isLibrary ? 'self' : _nativeData.getUnescapedJSInteropName(e.name);
   }
 
   /// Returns a JavaScript path specifying the context in which
   /// [element.fixedBackendName] should be evaluated. Only applicable for
   /// elements using typed JavaScript interop.
   /// For example: fixedBackendPath for the static method createMap in the
   /// Map class of the goog.map JavaScript library would have path
   /// "goog.maps.Map".
   String fixedBackendMethodPath(MethodElement element) {
     return _fixedBackendPath(element);
   }
 
   String _fixedBackendPath(Element element) {
-    if (!backend.nativeData.isJsInterop(element)) return null;
+    if (!_nativeData.isJsInterop(element)) return null;
     if (element.isInstanceMember) return 'this';
     if (element.isConstructor) return _fixedBackendPath(element.enclosingClass);
     if (element.isLibrary) return 'self';
     var sb = new StringBuffer();
     sb..write(_jsNameHelper(element.library));
 
     if (element.enclosingClass != null && element.enclosingClass != element) {
       sb..write('.')..write(_jsNameHelper(element.enclosingClass));
     }
     return sb.toString();
@@ skipping 61 matching lines @@
         List<String> suffix = callSuffixForStructure(selector.callStructure);
         if (selector.name == Identifiers.call) {
           // Derive the annotated name for this variant of 'call'.
           return deriveCallMethodName(suffix);
         }
         jsAst.Name disambiguatedName =
             _disambiguateMember(selector.memberName, suffix);
         return disambiguatedName; // Methods other than call are not annotated.
 
       default:
-        reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
+        throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
             'Unexpected selector kind: ${selector.kind}');
-        return null;
     }
   }
 
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
   jsAst.Name invocationMirrorInternalName(Selector selector) =>
       invocationName(selector);
 
   /**
@@ skipping 34 matching lines @@
   jsAst.Name globalPropertyName(Element element) {
     return _disambiguateGlobal(element);
   }
 
   /**
    * Returns the JavaScript property name used to store an instance field.
    */
   jsAst.Name instanceFieldPropertyName(FieldElement element) {
     ClassElement enclosingClass = element.enclosingClass;
 
-    if (backend.nativeData.hasFixedBackendName(element)) {
-      return new StringBackedName(
-          backend.nativeData.getFixedBackendName(element));
+    if (_nativeData.hasFixedBackendName(element)) {
+      return new StringBackedName(_nativeData.getFixedBackendName(element));
     }
 
     // Some elements, like e.g. instances of BoxFieldElement are special.
     // They are created with a unique and safe name for the element model.
     // While their name is unique, it is not very readable. So we try to
     // preserve the original, proposed name.
     // However, as boxes are not really instances of classes, the usual naming
     // scheme that tries to avoid name clashes with super classes does not
     // apply. So we can directly grab a name.
     Entity asEntity = element;
     if (asEntity is JSEntity) {
       return _disambiguateInternalMember(
           element, () => asEntity.declaredEntity.name);
     }
 
     // If the name of the field might clash with another field,
     // use a mangled field name to avoid potential clashes.
     // Note that if the class extends a native class, that native class might
     // have fields with fixed backend names, so we assume the worst and always
     // mangle the field names of classes extending native classes.
     // Methods on such classes are stored on the interceptor, not the instance,
     // so only fields have the potential to clash with a native property name.
-    if (closedWorld.isUsedAsMixin(enclosingClass) ||
+    if (_closedWorld.isUsedAsMixin(enclosingClass) ||
         _isShadowingSuperField(element) ||
         _isUserClassExtendingNative(enclosingClass)) {
       String proposeName() => '${enclosingClass.name}_${element.name}';
       return _disambiguateInternalMember(element, proposeName);
     }
 
     // No superclass uses the disambiguated name as a property name, so we can
     // use it for this field. This generates nicer field names since otherwise
     // the field name would have to be mangled.
     return _disambiguateMember(element.memberName);
   }
 
   bool _isShadowingSuperField(Element element) {
     return element.enclosingClass.hasFieldShadowedBy(element);
   }
 
   /// True if [class_] is a non-native class that inherits from a native class.
   bool _isUserClassExtendingNative(ClassElement class_) {
-    return !backend.nativeData.isNativeClass(class_) &&
-        backend.nativeData.isNativeOrExtendsNative(class_.superclass);
+    return !_nativeData.isNativeClass(class_) &&
+        _nativeData.isNativeOrExtendsNative(class_.superclass);
   }
 
   /// Annotated name for the setter of [element].
   jsAst.Name setterForElement(MemberElement element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
     jsAst.Name name = _disambiguateMember(element.memberName);
     return deriveSetterName(name);
   }
 
@@ skipping 357 matching lines @@
     String disambiguated = name;
     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.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";
       return cls.name;
     }
 
     List<String> names = classes
-        .where((cls) => !backend.nativeData.isNativeOrExtendsNative(cls))
+        .where((cls) => !_nativeData.isNativeOrExtendsNative(cls))
         .map(abbreviate)
         .toList();
     // There is one dispatch mechanism for all native classes.
-    if (classes.any((cls) => backend.nativeData.isNativeOrExtendsNative(cls))) {
+    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 = _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<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(_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 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 == _helpers.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 199 matching lines @@
  *     EventKeyProvider_keyup  // const EventKeyProvider('keyup')
  *
  */
 class ConstantNamingVisitor implements ConstantValueVisitor {
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static const MAX_FRAGMENTS = 5;
   static const MAX_EXTRA_LENGTH = 30;
   static const DEFAULT_TAG_LENGTH = 3;
 
   final RuntimeTypesEncoder rtiEncoder;
-  final DiagnosticReporter reporter;
   final CodegenWorldBuilder codegenWorldBuilder;
   final ConstantCanonicalHasher hasher;
 
   String root = null; // First word, usually a type name.
   bool failed = false; // Failed to generate something pretty.
   List<String> fragments = <String>[];
   int length = 0;
 
-  ConstantNamingVisitor(
-      this.rtiEncoder, this.reporter, this.codegenWorldBuilder, this.hasher);
+  ConstantNamingVisitor(this.rtiEncoder, this.codegenWorldBuilder, this.hasher);
 
   String getName(ConstantValue constant) {
     _visit(constant);
     if (root == null) return 'CONSTANT';
     if (failed) return '${root}_${getHashTag(constant, DEFAULT_TAG_LENGTH)}';
     if (fragments.length == 1) return 'C_${root}';
     return fragments.join('_');
   }
 
   String getHashTag(ConstantValue constant, int width) =>
@@ skipping 150 matching lines @@
       case SyntheticConstantKind.DUMMY_INTERCEPTOR:
         add('dummy_receiver');
         break;
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
         // Omit. These are opaque deferred indexes with nothing helpful to add.
         break;
       case SyntheticConstantKind.NAME:
         add('name');
         break;
       default:
-        reporter.internalError(
+        throw new SpannableAssertionFailure(
             CURRENT_ELEMENT_SPANNABLE, "Unexpected SyntheticConstantValue");
     }
   }
 
   @override
   void visitDeferred(DeferredConstantValue constant, [_]) {
     addRoot('Deferred');
   }
 }
 
 /**
  * Generates canonical hash values for [ConstantValue]s.
  *
  * Unfortunately, [Constant.hashCode] is not stable under minor perturbations,
  * so it can't be used for generating names.  This hasher keeps consistency
  * between runs by basing hash values of the names of elements, rather than
  * their hashCodes.
  */
 class ConstantCanonicalHasher implements ConstantValueVisitor<int, Null> {
   static const _MASK = 0x1fffffff;
   static const _UINT32_LIMIT = 4 * 1024 * 1024 * 1024;
 
-  final DiagnosticReporter reporter;
   final RuntimeTypesEncoder rtiEncoder;
   final CodegenWorldBuilder codegenWorldBuilder;
   final Map<ConstantValue, int> hashes = new Map<ConstantValue, int>();
 
-  ConstantCanonicalHasher(
-      this.rtiEncoder, this.reporter, this.codegenWorldBuilder);
+  ConstantCanonicalHasher(this.rtiEncoder, this.codegenWorldBuilder);
 
   int getHash(ConstantValue constant) => _visit(constant);
 
   int _visit(ConstantValue constant) {
     int hash = hashes[constant];
     if (hash == null) {
       hash = _finish(constant.accept(this, null));
       hashes[constant] = hash;
     }
     return hash;
@@ skipping 67 matching lines @@
 
   @override
   int visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.valueKind) {
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
         // These contain a deferred opaque index into metadata. There is nothing
         // we can access that is stable between compiles.  Luckily, since they
         // resolve to integer indexes, they're always part of a larger constant.
         return 0;
       default:
-        reporter.internalError(
+        throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE,
             'SyntheticConstantValue should never be named and '
             'never be subconstant');
-        return 0;
     }
   }
 
   @override
   int visitDeferred(DeferredConstantValue constant, [_]) {
     // TODO(sra): Investigate that the use of hashCode here is probably a source
     // of instability.
     int hash = constant.prefix.hashCode;
     return _combine(hash, _visit(constant.referenced));
   }
@@ skipping 142 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);
   }
 }