Handle js interop members in impact computation.

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 '../common_elements.dart' show ElementEnvironment;
 import '../elements/entities.dart';
 import '../native/behavior.dart' show NativeBehavior;
@@ skipping 20 matching lines @@
   bool isNativeOrExtendsNative(ClassEntity element);
 
   /// Returns `true` if js interop features are used.
   bool get isJsInteropUsed;
 
   /// Returns `true` if [element] is a JsInterop library.
   bool isJsInteropLibrary(LibraryEntity element);
 
   /// Returns `true` if [element] is a JsInterop class.
   bool isJsInteropClass(ClassEntity element);
+
+  /// Returns `true` if [element] is a JsInterop member.
+  bool isJsInteropMember(MemberEntity 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 NativeBasicData {
   /// Returns `true` if [element] corresponds to a native JavaScript member.
   ///
   /// A member is marked as native either through the native mechanism
@@ skipping 46 matching lines @@
 }
 
 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);
+  /// Marks [element] as an explicit part of js interop.
+  ///
+  /// If [name] is provided, it sets the explicit js interop name for the
+  /// library [element], other the js interop name is expected to be computed
+  /// later.
+  void markAsJsInteropLibrary(LibraryEntity element, {String name});
 
-  /// Marks [element] as an explicit part of JsInterop. The js interop name is
-  /// expected to be computed later.
-  void markAsJsInteropClass(ClassEntity element);
+  /// Marks [element] as an explicit part of js interop.
+  ///
+  /// If [name] is provided, it sets the explicit js interop name for the
+  /// class [element], other the js interop name is expected to be computed
+  /// later.
+  void markAsJsInteropClass(ClassEntity element,
+      {String name, bool isAnonymous: false});
+
+  /// Marks [element] as an explicit part of js interop and sets the explicit js
+  /// interop [name] for the member [element].
+  void markAsJsInteropMember(MemberEntity element, String name);
 
   /// Creates the [NativeBasicData] object for the data collected in this
   /// builder.
   NativeBasicData close(ElementEnvironment environment);
 }
 
 abstract class NativeDataBuilder {
   /// Registers the [behavior] for calling the native [method].
   void setNativeMethodBehavior(FunctionEntity method, NativeBehavior behavior);
 
   /// Registers the [behavior] for reading from the native [field].
   void setNativeFieldLoadBehavior(FieldEntity field, NativeBehavior behavior);
 
   /// Registers the [behavior] for writing to the native [field].
   void setNativeFieldStoreBehavior(FieldEntity field, NativeBehavior behavior);
 
-  /// Returns [element] as an explicit part of JsInterop. The js interop name is
+  /// Marks [element] as an explicit part of JsInterop. The js interop name is
   /// expected to be computed later.
   void markAsJsInteropMember(MemberEntity element);
 
   /// Sets the native [name] for the member [element]. This name is used for
   /// [element] in the generated JavaScript.
   void setNativeMemberName(MemberEntity element, String name);
 
   /// Sets the explicit js interop [name] for the library [element].
   void setJsInteropLibraryName(LibraryEntity element, String name);
 
@@ skipping 10 matching lines @@
   NativeData close();
 }
 
 class NativeBasicDataBuilderImpl implements NativeBasicDataBuilder {
   /// 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>();
+  Map<LibraryEntity, String> jsInteropLibraries = <LibraryEntity, String>{};
 
   /// The JavaScript classes implemented via typed JavaScript interop.
-  Set<ClassEntity> jsInteropClasses = new Set<ClassEntity>();
+  Map<ClassEntity, String> jsInteropClasses = <ClassEntity, String>{};
+
+  /// JavaScript interop classes annotated with `@anonymous`
+  Set<ClassEntity> anonymousJsInteropClasses = new Set<ClassEntity>();
+
+  /// The JavaScript members implemented via typed JavaScript interop.
+  Map<MemberEntity, String> jsInteropMembers = <MemberEntity, String>{};
 
   /// 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 tagText) {
     // TODO(johnniwinther): Assert that this is only called once. The memory
     // compiler copies pre-processed elements into a new compiler through
     // [Compiler.onLibraryScanned] and thereby causes multiple calls to this
     // method.
     assert(
         nativeClassTagInfo[cls] == null ||
             nativeClassTagInfo[cls].text == tagText,
         failedAt(
             cls,
             "Native tag info set inconsistently on $cls: "
             "Existing tag info '${nativeClassTagInfo[cls]}', "
             "new tag info '$tagText'."));
     nativeClassTagInfo[cls] = new NativeClassTag(tagText);
   }
 
   @override
-  void markAsJsInteropLibrary(LibraryEntity element) {
-    jsInteropLibraries.add(element);
+  void markAsJsInteropLibrary(LibraryEntity element, {String name}) {
+    jsInteropLibraries[element] = name;
   }
 
   @override
-  void markAsJsInteropClass(ClassEntity element) {
-    jsInteropClasses.add(element);
+  void markAsJsInteropClass(ClassEntity element,
+      {String name, bool isAnonymous: false}) {
+    jsInteropClasses[element] = name;

[Siggi Cherem (dart-lang), 2017/08/08 00:06:46]

do we expect a name when isAnonymous is true? should we report an error in that
case?

[Johnni Winther, 2017/08/09 08:34:36]

We should. Adding a TODO

+    if (isAnonymous) {
+      anonymousJsInteropClasses.add(element);
+    }
+  }
+
+  @override
+  void markAsJsInteropMember(MemberEntity element, String name) {
+    jsInteropMembers[element] = name;
   }
 
   NativeBasicData close(ElementEnvironment environment) {
     return new NativeBasicDataImpl(
-        environment, nativeClassTagInfo, jsInteropLibraries, jsInteropClasses);
+        environment,
+        nativeClassTagInfo,
+        jsInteropLibraries,
+        jsInteropClasses,
+        anonymousJsInteropClasses,
+        jsInteropMembers);
   }
 }
 
 class NativeBasicDataImpl implements NativeBasicData {
   final ElementEnvironment _env;
 
   /// Tag info for native JavaScript classes names. See
   /// [setNativeClassTagInfo].
   final Map<ClassEntity, NativeClassTag> nativeClassTagInfo;
 
   /// The JavaScript libraries implemented via typed JavaScript interop.
-  final Set<LibraryEntity> jsInteropLibraries;
+  final Map<LibraryEntity, String> jsInteropLibraries;
 
   /// The JavaScript classes implemented via typed JavaScript interop.
-  final Set<ClassEntity> jsInteropClasses;
+  final Map<ClassEntity, String> jsInteropClasses;
 
-  NativeBasicDataImpl(this._env, this.nativeClassTagInfo,
-      this.jsInteropLibraries, this.jsInteropClasses);
+  /// JavaScript interop classes annotated with `@anonymous`
+  final Set<ClassEntity> anonymousJsInteropClasses;
 
-  /// Returns `true` if [cls] is a native class.
+  /// The JavaScript members implemented via typed JavaScript interop.
+  final Map<MemberEntity, String> jsInteropMembers;
+
+  NativeBasicDataImpl(
+      this._env,
+      this.nativeClassTagInfo,
+      this.jsInteropLibraries,
+      this.jsInteropClasses,
+      this.anonymousJsInteropClasses,
+      this.jsInteropMembers);
+
+  @override
   bool isNativeClass(ClassEntity element) {
     if (isJsInteropClass(element)) return true;
     return nativeClassTagInfo.containsKey(element);
   }
 
-  /// Returns the list of non-directive native tag words for [cls].
+  @override
   List<String> getNativeTagsOfClass(ClassEntity cls) {
     return nativeClassTagInfo[cls].names;
   }
 
-  /// Returns `true` if [cls] has a `!nonleaf` tag word.
+  @override
   bool hasNativeTagsForcedNonLeaf(ClassEntity cls) {
     return nativeClassTagInfo[cls].isNonLeaf;
   }
 
+  @override
   bool get isJsInteropUsed =>
       jsInteropLibraries.isNotEmpty || jsInteropClasses.isNotEmpty;
 
-  /// Returns `true` if [element] is explicitly marked as part of JsInterop.
+  @override
   bool isJsInteropLibrary(LibraryEntity element) {
-    return jsInteropLibraries.contains(element);
+    return jsInteropLibraries.containsKey(element);
   }
 
-  /// Returns `true` if [element] is explicitly marked as part of JsInterop.
+  @override
   bool isJsInteropClass(ClassEntity element) {
-    return jsInteropClasses.contains(element);
+    return jsInteropClasses.containsKey(element);
   }
 
-  /// Returns `true` if [element] or any of its superclasses is native.
+  @override
+  bool isJsInteropMember(MemberEntity element) {
+    return jsInteropMembers.containsKey(element);
+  }
+
+  @override
   bool isNativeOrExtendsNative(ClassEntity element) {
     if (element == null) return false;
     if (isNativeClass(element) || isJsInteropClass(element)) {
       return true;
     }
     return isNativeOrExtendsNative(_env.getSuperClass(element));
   }
 }
 
 class NativeDataBuilderImpl implements NativeDataBuilder {
-  final NativeBasicData _nativeBasicData;
+  final NativeBasicDataImpl _nativeBasicData;
 
   /// 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 libraries implemented via typed JavaScript
   /// interop.
-  Map<LibraryEntity, String> jsInteropLibraryNames = <LibraryEntity, String>{};
+  final Map<LibraryEntity, String> jsInteropLibraries;
 
   /// JavaScript interop classes annotated with `@anonymous`
-  Set<ClassEntity> anonymousJsInteropClasses = new Set<ClassEntity>();
+  final Set<ClassEntity> anonymousJsInteropClasses;
 
   /// The JavaScript names for classes implemented via typed JavaScript
   /// interop.
-  Map<ClassEntity, String> jsInteropClassNames = <ClassEntity, String>{};
+  final Map<ClassEntity, String> jsInteropClasses;
 
   /// The JavaScript names for members implemented via typed JavaScript
   /// interop.
-  Map<MemberEntity, String> jsInteropMemberNames = <MemberEntity, String>{};
+  final Map<MemberEntity, String> jsInteropMembers;
 
-  NativeDataBuilderImpl(this._nativeBasicData);
+  NativeDataBuilderImpl(this._nativeBasicData)
+      : jsInteropLibraries = _nativeBasicData.jsInteropLibraries,
+        jsInteropClasses = _nativeBasicData.jsInteropClasses,
+        anonymousJsInteropClasses = _nativeBasicData.anonymousJsInteropClasses,
+        jsInteropMembers = _nativeBasicData.jsInteropMembers;
 
   /// 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(
         nativeMemberName[element] == null || nativeMemberName[element] == name,
         failedAt(
@@ skipping 18 matching lines @@
   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(
         _nativeBasicData.isJsInteropLibrary(element),
         failedAt(element,
             'Library $element is not js interop but given a js interop name.'));
-    jsInteropLibraryNames[element] = name;
+    jsInteropLibraries[element] = name;
   }
 
   @override
   void markJsInteropClassAsAnonymous(ClassEntity element) {
     anonymousJsInteropClasses.add(element);
   }
 
   /// Sets the explicit js interop [name] for the class [element].
   void setJsInteropClassName(ClassEntity element, String name) {
     assert(
         _nativeBasicData.isJsInteropClass(element),
         failedAt(element,
             'Class $element is not js interop but given a js interop name.'));
-    jsInteropClassNames[element] = name;
+    jsInteropClasses[element] = name;
   }
 
   @override
   void markAsJsInteropMember(MemberEntity element) {
-    jsInteropMemberNames[element] = null;
+    jsInteropMembers[element] = null;
   }
 
   /// Sets the explicit js interop [name] for the member [element].
   void setJsInteropMemberName(MemberEntity element, String name) {
     assert(
-        jsInteropMemberNames.containsKey(element),
+        jsInteropMembers.containsKey(element),
         failedAt(element,
             'Member $element is not js interop but given a js interop name.'));
-    jsInteropMemberNames[element] = name;
+    jsInteropMembers[element] = name;
   }
 
   @override
   NativeData close() => new NativeDataImpl(
       _nativeBasicData,
       nativeMemberName,
       nativeMethodBehavior,
       nativeFieldLoadBehavior,
       nativeFieldStoreBehavior,
-      jsInteropLibraryNames,
+      jsInteropLibraries,
       anonymousJsInteropClasses,
-      jsInteropClassNames,
-      jsInteropMemberNames);
+      jsInteropClasses,
+      jsInteropMembers);
 }
 
 class NativeDataImpl implements NativeData, NativeBasicDataImpl {
   /// Prefix used to escape JS names that are not valid Dart names
   /// when using JSInterop.
   static const String _jsInteropEscapePrefix = r'JS$';
 
   final NativeBasicDataImpl _nativeBasicData;
 
   /// The JavaScript names for native JavaScript elements implemented.
   final Map<MemberEntity, String> nativeMemberName;
 
   /// Cache for [NativeBehavior]s for calling native methods.
   final Map<FunctionEntity, NativeBehavior> nativeMethodBehavior;
 
   /// Cache for [NativeBehavior]s for reading from native fields.
   final Map<MemberEntity, NativeBehavior> nativeFieldLoadBehavior;
 
   /// Cache for [NativeBehavior]s for writing to native fields.
   final Map<MemberEntity, NativeBehavior> nativeFieldStoreBehavior;
 
   /// The JavaScript names for libraries implemented via typed JavaScript
   /// interop.
-  final Map<LibraryEntity, String> jsInteropLibraryNames;
+  final Map<LibraryEntity, String> jsInteropLibraries;
 
   /// JavaScript interop classes annotated with `@anonymous`
   final Set<ClassEntity> anonymousJsInteropClasses;
 
   /// The JavaScript names for classes implemented via typed JavaScript
   /// interop.
-  final Map<ClassEntity, String> jsInteropClassNames;
+  final Map<ClassEntity, String> jsInteropClasses;
 
   /// The JavaScript names for members implemented via typed JavaScript
   /// interop.
-  final Map<MemberEntity, String> jsInteropMemberNames;
+  final Map<MemberEntity, String> jsInteropMembers;
 
   NativeDataImpl(
       this._nativeBasicData,
       this.nativeMemberName,
       this.nativeMethodBehavior,
       this.nativeFieldLoadBehavior,
       this.nativeFieldStoreBehavior,
-      this.jsInteropLibraryNames,
+      this.jsInteropLibraries,
       this.anonymousJsInteropClasses,
-      this.jsInteropClassNames,
-      this.jsInteropMemberNames);
+      this.jsInteropClasses,
+      this.jsInteropMembers);
 
   @override
   bool isAnonymousJsInteropClass(ClassEntity element) {
     return anonymousJsInteropClasses.contains(element);
   }
 
   /// Returns `true` if [cls] is a native class.
   bool isNativeClass(ClassEntity element) =>
       _nativeBasicData.isNativeClass(element);
 
@@ skipping 14 matching lines @@
   /// Returns `true` if [element] is a JsInterop class.
   bool isJsInteropClass(ClassEntity element) =>
       _nativeBasicData.isJsInteropClass(element);
 
   /// Returns `true` if [element] or any of its superclasses is native.
   bool isNativeOrExtendsNative(ClassEntity element) =>
       _nativeBasicData.isNativeOrExtendsNative(element);
 
   /// Returns the explicit js interop name for library [element].
   String getJsInteropLibraryName(LibraryEntity element) {
-    return jsInteropLibraryNames[element];
+    return jsInteropLibraries[element];
   }
 
   /// Returns the explicit js interop name for class [element].
   String getJsInteropClassName(ClassEntity element) {
-    return jsInteropClassNames[element];
+    return jsInteropClasses[element];
   }
 
   /// Returns the explicit js interop name for member [element].
   String getJsInteropMemberName(MemberEntity element) {
-    return jsInteropMemberNames[element];
+    return jsInteropMembers[element];
   }
 
   /// Returns `true` if [element] is explicitly marked as part of JsInterop.
   bool _isJsInteropMember(MemberEntity element) {
-    return jsInteropMemberNames.containsKey(element);
+    return jsInteropMembers.containsKey(element);
   }
 
   /// Returns `true` if [element] is a JsInterop method.
   bool isJsInteropMember(MemberEntity element) {
     if (element.isFunction ||
         element.isConstructor ||
         element.isGetter ||
         element.isSetter) {
       FunctionEntity function = element;
       if (!function.isExternal) return false;
@@ skipping 38 matching lines @@
     return 'self';
   }
 
   String _jsClassNameHelper(ClassEntity element) {
     String jsInteropName = getJsInteropClassName(element);
     if (jsInteropName != null && jsInteropName.isNotEmpty) return jsInteropName;
     return computeUnescapedJSInteropName(element.name);
   }
 
   String _jsMemberNameHelper(MemberEntity element) {
-    String jsInteropName = jsInteropMemberNames[element];
+    String jsInteropName = jsInteropMembers[element];
     assert(
-        !(jsInteropMemberNames.containsKey(element) && jsInteropName == null),
+        !(jsInteropMembers.containsKey(element) && jsInteropName == null),
         failedAt(
             element,
             'Member $element is js interop but js interop name has not yet '
             'been computed.'));
     if (jsInteropName != null && jsInteropName.isNotEmpty) {
       return jsInteropName;
     }
     return computeUnescapedJSInteropName(element.name);
   }
 
@@ skipping 59 matching lines @@
 
   /// Apply JS$ escaping scheme to convert possible escaped Dart names into
   /// JS names.
   String computeUnescapedJSInteropName(String name) {
     return name.startsWith(_jsInteropEscapePrefix)
         ? name.substring(_jsInteropEscapePrefix.length)
         : name;
   }
 
   @override
-  Set<ClassEntity> get jsInteropClasses => _nativeBasicData.jsInteropClasses;
-
-  @override
-  Set<LibraryEntity> get jsInteropLibraries =>
-      _nativeBasicData.jsInteropLibraries;
-
-  @override
   Map<ClassEntity, NativeClassTag> get nativeClassTagInfo =>
       _nativeBasicData.nativeClassTagInfo;
 
   @override
   ElementEnvironment get _env => _nativeBasicData._env;
 }
 
 class NativeClassTag {
   final List<String> names;
   final bool isNonLeaf;
@@ skipping 22 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;
 }