Pending renames and cleanups after commits

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

 // Copyright (c) 2016, 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.native_data;
 
 import '../common.dart';
 import '../elements/elements.dart' show ClassElement;
 import '../elements/entities.dart';
 import '../native/behavior.dart' show NativeBehavior;
 import '../util/util.dart';
 
-/// Basic information for native classes and methods and js-interop
-/// classes.
+/// Basic information for native classes and js-interop libraries and classes.
 ///
-/// This information is computed during loading using [NativeClassDataBuilder].
-abstract class NativeClassData {
+/// This information is computed during loading using [NativeBasicDataBuilder].
+abstract class NativeBasicData {
   /// Returns `true` if [cls] corresponds to a native JavaScript class.
   ///
   /// A class is marked as native either through the `@Native(...)` annotation
   /// allowed for internal libraries or via the typed JavaScriptInterop
   /// mechanism allowed for user libraries.
   bool isNativeClass(ClassEntity element);
 
   /// Returns the list of non-directive native tag words for [cls].
   List<String> getNativeTagsOfClass(ClassEntity cls);
 
   /// Returns `true` if [cls] has a `!nonleaf` tag word.
   bool hasNativeTagsForcedNonLeaf(ClassEntity cls);
 
   /// Returns `true` if [element] or any of its superclasses is native.
   bool isNativeOrExtendsNative(ClassEntity element);
 
   /// Returns `true` if [element] is a JsInterop library.
   bool isJsInteropLibrary(LibraryEntity element);
 
   /// Returns `true` if [element] is a JsInterop class.
   bool isJsInteropClass(ClassEntity element);
 }
 
 /// Additional element information for native classes and methods and js-interop
 /// methods.
 ///
 /// This information is computed during resolution using [NativeDataBuilder].
-abstract class NativeData extends NativeClassData {
+abstract class NativeData extends NativeBasicData {
   /// Returns `true` if [element] corresponds to a native JavaScript member.
   ///
   /// A member is marked as native either through the native mechanism
   /// (`@Native(...)` or the `native` pseudo keyword) allowed for internal
   /// libraries or via the typed JavaScriptInterop mechanism allowed for user
   /// libraries.
   bool isNativeMember(MemberEntity element);
 
   /// Returns the [NativeBehavior] for calling the native [method].
   NativeBehavior getNativeMethodBehavior(FunctionEntity method);
@@ skipping 28 matching lines @@
   String getJsInteropClassName(ClassEntity element);
 
   /// Returns the explicit js interop name for member [element].
   String getJsInteropMemberName(MemberEntity element);
 
   /// Apply JS$ escaping scheme to convert possible escaped Dart names into
   /// JS names.
   String computeUnescapedJSInteropName(String name);
 }
 
-abstract class NativeClassDataBuilder {
+abstract class NativeBasicDataBuilder {
   /// Sets the native tag info for [cls].
   ///
   /// The tag info string contains comma-separated 'words' which are either
   /// dispatch tags (having JavaScript identifier syntax) and directives that
   /// begin with `!`.
   void setNativeClassTagInfo(ClassEntity cls, String tagInfo);
 
   /// Marks [element] as an explicit part of JsInterop. The js interop name is
   /// expected to be computed later.
   void markAsJsInteropLibrary(LibraryEntity element);
@@ skipping 24 matching lines @@
   /// Sets the explicit js interop [name] for the library [element].
   void setJsInteropLibraryName(LibraryEntity element, String name);
 
   /// Sets the explicit js interop [name] for the class [element].
   void setJsInteropClassName(ClassEntity element, String name);
 
   /// Sets the explicit js interop [name] for the member [element].
   void setJsInteropMemberName(MemberEntity element, String name);
 }
 
-class NativeClassDataImpl implements NativeClassDataBuilder, NativeClassData {
+class NativeBasicDataImpl implements NativeBasicDataBuilder, NativeBasicData {
   /// Tag info for native JavaScript classes names. See
   /// [setNativeClassTagInfo].
   Map<ClassEntity, NativeClassTag> nativeClassTagInfo =
       <ClassEntity, NativeClassTag>{};
 
   /// The JavaScript libraries implemented via typed JavaScript interop.
   Set<LibraryEntity> jsInteropLibraries = new Set<LibraryEntity>();
 
   /// The JavaScript classes implemented via typed JavaScript interop.
   Set<ClassEntity> jsInteropClasses = new Set<ClassEntity>();
@@ skipping 64 matching lines @@
     assert(element.isResolved);
     return isNativeOrExtendsNative(element.superclass);
   }
 }
 
 class NativeDataImpl implements NativeDataBuilder, NativeData {
   /// Prefix used to escape JS names that are not valid Dart names
   /// when using JSInterop.
   static const String _jsInteropEscapePrefix = r'JS$';
 
-  final NativeClassData _nativeClassData;
+  final NativeBasicData _nativeBaseData;

[Siggi Cherem (dart-lang), 2017/03/17 23:50:55]

should the variable be BasicData too? I have a feeling you did that in a
following CL, though.

 
   /// The JavaScript names for native JavaScript elements implemented.
   Map<MemberEntity, String> nativeMemberName = <MemberEntity, String>{};
 
   /// Cache for [NativeBehavior]s for calling native methods.
   Map<FunctionEntity, NativeBehavior> nativeMethodBehavior =
       <FunctionEntity, NativeBehavior>{};
 
   /// Cache for [NativeBehavior]s for reading from native fields.
   Map<MemberEntity, NativeBehavior> nativeFieldLoadBehavior =
       <FieldEntity, NativeBehavior>{};
 
   /// Cache for [NativeBehavior]s for writing to native fields.
   Map<MemberEntity, NativeBehavior> nativeFieldStoreBehavior =
       <FieldEntity, NativeBehavior>{};
 
   /// The JavaScript names for elements implemented via typed JavaScript
   /// interop.
   Map<LibraryEntity, String> jsInteropLibraryNames = <LibraryEntity, String>{};
   Map<ClassEntity, String> jsInteropClassNames = <ClassEntity, String>{};
 
   /// The JavaScript names for elements implemented via typed JavaScript
   /// interop.
   Map<MemberEntity, String> jsInteropMemberNames = <MemberEntity, String>{};
 
-  NativeDataImpl(this._nativeClassData);
+  NativeDataImpl(this._nativeBaseData);
 
   /// Sets the native [name] for the member [element]. This name is used for
   /// [element] in the generated JavaScript.
   void setNativeMemberName(MemberEntity element, String name) {
     // TODO(johnniwinther): Avoid setting this more than once. The enqueuer
     // might enqueue [element] several times (before processing it) and computes
     // name on each call to `internalAddToWorkList`.
     assert(invariant(element,
         nativeMemberName[element] == null || nativeMemberName[element] == name,
         message: "Native member name set inconsistently on $element: "
@@ skipping 12 matching lines @@
     nativeFieldLoadBehavior[field] = behavior;
   }
 
   /// Registers the [behavior] for writing to the native [field].
   void setNativeFieldStoreBehavior(FieldEntity field, NativeBehavior behavior) {
     nativeFieldStoreBehavior[field] = behavior;
   }
 
   /// Sets the explicit js interop [name] for the library [element].
   void setJsInteropLibraryName(LibraryEntity element, String name) {
-    assert(invariant(element, _nativeClassData.isJsInteropLibrary(element),
+    assert(invariant(element, _nativeBaseData.isJsInteropLibrary(element),
         message:
             'Library $element is not js interop but given a js interop name.'));
     jsInteropLibraryNames[element] = name;
   }
 
   /// Sets the explicit js interop [name] for the class [element].
   void setJsInteropClassName(ClassEntity element, String name) {
-    assert(invariant(element, _nativeClassData.isJsInteropClass(element),
+    assert(invariant(element, _nativeBaseData.isJsInteropClass(element),
         message:
             'Class $element is not js interop but given a js interop name.'));
     jsInteropClassNames[element] = name;
   }
 
   @override
   void markAsJsInteropMember(MemberEntity element) {
     jsInteropMemberNames[element] = null;
   }
 
   /// Returns `true` if [element] is explicitly marked as part of JsInterop.
   bool _isJsInteropMember(MemberEntity element) {
     return jsInteropMemberNames.containsKey(element);
   }
 
   /// Sets the explicit js interop [name] for the member [element].
   void setJsInteropMemberName(MemberEntity element, String name) {
     assert(invariant(element, _isJsInteropMember(element),
         message:
             'Member $element is not js interop but given a js interop name.'));
     jsInteropMemberNames[element] = name;
   }
 
   /// Returns `true` if [cls] is a native class.
   bool isNativeClass(ClassEntity element) =>
-      _nativeClassData.isNativeClass(element);
+      _nativeBaseData.isNativeClass(element);
 
   /// Returns the list of non-directive native tag words for [cls].
   List<String> getNativeTagsOfClass(ClassEntity cls) =>
-      _nativeClassData.getNativeTagsOfClass(cls);
+      _nativeBaseData.getNativeTagsOfClass(cls);
 
   /// Returns `true` if [cls] has a `!nonleaf` tag word.
   bool hasNativeTagsForcedNonLeaf(ClassEntity cls) =>
-      _nativeClassData.hasNativeTagsForcedNonLeaf(cls);
+      _nativeBaseData.hasNativeTagsForcedNonLeaf(cls);
 
   /// Returns `true` if [element] is a JsInterop library.
   bool isJsInteropLibrary(LibraryEntity element) =>
-      _nativeClassData.isJsInteropLibrary(element);
+      _nativeBaseData.isJsInteropLibrary(element);
 
   /// Returns `true` if [element] is a JsInterop class.
   bool isJsInteropClass(ClassEntity element) =>
-      _nativeClassData.isJsInteropClass(element);
+      _nativeBaseData.isJsInteropClass(element);
 
   /// Returns `true` if [element] or any of its superclasses is native.
   bool isNativeOrExtendsNative(ClassEntity element) =>
-      _nativeClassData.isNativeOrExtendsNative(element);
+      _nativeBaseData.isNativeOrExtendsNative(element);
 
   /// Returns the explicit js interop name for library [element].
   String getJsInteropLibraryName(LibraryEntity element) {
     return jsInteropLibraryNames[element];
   }
 
   /// Returns the explicit js interop name for class [element].
   String getJsInteropClassName(ClassEntity element) {
     return jsInteropClassNames[element];
   }
@@ skipping 162 matching lines @@
   int get hashCode => Hashing.listHash(names, isNonLeaf.hashCode);
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! NativeClassTag) return false;
     return equalElements(names, other.names) && isNonLeaf == other.isNonLeaf;
   }
 
   String toString() => text;
 }