Split NativeData

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, Element, FieldElement, FunctionElement, MemberElement;
+    show
+        ClassElement,
+        Element,
+        FieldElement,
+        FunctionElement,
+        MemberElement,
+        MethodElement;
 import '../elements/entities.dart';
 import '../native/behavior.dart' show NativeBehavior;
 
 /// Additional element information for native classes and methods and js-interop
 /// methods.
-class NativeData {
+abstract class NativeData {
+  /// 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 `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

[Siggi Cherem (dart-lang), 2017/03/14 00:15:59]

doesn't this require also `external`?

[Johnni Winther, 2017/03/14 15:48:04]

We correctly don't use external in dart:html.

+  /// libraries or via the typed JavaScriptInterop mechanism allowed for user
+  /// libraries.
+  bool isNativeMember(MemberEntity element);
+
+  /// Returns `true` if [element] or any of its superclasses is native.
+  bool isNativeOrExtendsNative(ClassElement element);
+
+  /// Returns `true` if the name of [element] is fixed for the generated
+  /// JavaScript.
+  bool hasFixedBackendName(Element element);
+
+  /// Computes the name for [element] to use in the generated JavaScript. This
+  /// is either given through a native annotation or a js interop annotation.
+  String getFixedBackendName(Entity entity);
+
+  /// Returns the list of non-directive native tag words for [cls].
+  List<String> getNativeTagsOfClass(ClassElement cls);
+
+  /// Returns `true` if [cls] has a `!nonleaf` tag word.
+  bool hasNativeTagsForcedNonLeaf(ClassElement cls);
+
+  /// Returns the [NativeBehavior] for calling the native [method].
+  NativeBehavior getNativeMethodBehavior(MethodElement method);
+
+  /// Returns the [NativeBehavior] for reading from the native [field].
+  NativeBehavior getNativeFieldLoadBehavior(FieldElement field);
+
+  /// Returns the [NativeBehavior] for writing to the native [field].
+  NativeBehavior getNativeFieldStoreBehavior(FieldElement field);
+
+  /// Returns `true` if [element] is part of JsInterop.
+  bool isJsInterop(Element element);
+
+  /// Returns `true` if [element] is a JsInterop class.
+  bool isJsInteropClass(ClassElement element);
+
+  /// Returns `true` if [element] is a JsInterop method.
+  bool isJsInteropMethod(MethodElement element);
+
+  /// Returns the explicit js interop name for [element].
+  String getJsInteropName(Element element);
+
+  /// Apply JS$ escaping scheme to convert possible escaped Dart names into
+  /// JS names.
+  String getUnescapedJSInteropName(String name);
+}
+
+abstract class NativeDataBuilder {
+  /// 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 `!`.

[Siggi Cherem (dart-lang), 2017/03/14 00:15:59]

is there a more detailed description of the tags elsewhere, it might be worth
putting a link/dartdoc-reference here

[Johnni Winther, 2017/03/14 15:48:04]

Haven't seen any. Stephen might know more.

+  void setNativeClassTagInfo(ClassElement cls, String tagInfo);
+
+  /// Returns the list of native tag words for [cls].
+  List<String> getNativeTagsOfClassRaw(ClassElement cls);
+
+  /// Sets the native [name] for the member [element]. This name is used for
+  /// [element] in the generated JavaScript.
+  void setNativeMemberName(MemberElement element, String name);
+
+  /// Registers the [behavior] for calling the native [method].
+  void setNativeMethodBehavior(MethodElement method, NativeBehavior behavior);
+
+  /// Registers the [behavior] for reading from the native [field].
+  void setNativeFieldLoadBehavior(FieldElement field, NativeBehavior behavior);
+
+  /// Registers the [behavior] for writing to the native [field].
+  void setNativeFieldStoreBehavior(FieldElement field, NativeBehavior behavior);
+
+  /// Returns [element] as an explicit part of JsInterop. The js interop name is

[Siggi Cherem (dart-lang), 2017/03/14 00:15:59]

Returns => marks?

[Johnni Winther, 2017/03/14 15:48:04]

Done.

+  /// expected to be computed later.
+  void markAsJsInterop(Element element);
+
+  /// Sets the explicit js interop [name] for [element].
+  void setJsInteropName(Element element, String name);
+}
+
+class NativeDataImpl implements NativeData, NativeDataBuilder {
   /// The JavaScript names for elements implemented via typed JavaScript
   /// interop.
   Map<Element, String> jsInteropNames = <Element, String>{};
 
   /// The JavaScript names for native JavaScript elements implemented.
   Map<Element, String> nativeMemberName = <Element, String>{};
 
   /// Tag info for native JavaScript classes names. See
   /// [setNativeClassTagInfo].
   Map<ClassElement, String> nativeClassTagInfo = <ClassElement, String>{};
 
   /// Cache for [NativeBehavior]s for calling native methods.
-  Map<FunctionElement, NativeBehavior> nativeMethodBehavior =
-      <FunctionElement, NativeBehavior>{};
+  Map<MethodElement, NativeBehavior> nativeMethodBehavior =
+      <MethodElement, NativeBehavior>{};
 
   /// Cache for [NativeBehavior]s for reading from native fields.
   Map<MemberElement, NativeBehavior> nativeFieldLoadBehavior =
       <FieldElement, NativeBehavior>{};
 
   /// Cache for [NativeBehavior]s for writing to native fields.
   Map<MemberElement, NativeBehavior> nativeFieldStoreBehavior =
       <FieldElement, NativeBehavior>{};
 
   /// Prefix used to escape JS names that are not valid Dart names
@@ skipping 35 matching lines @@
 
       if (_isJsInterop(function)) return true;
       if (function.isClassMember) return isJsInterop(function.contextClass);
       if (function.isTopLevel) return isJsInterop(function.library);
       return false;
     } else {
       return _isJsInterop(element);
     }
   }
 
+  /// Returns `true` if [element] is a JsInterop class.
+  bool isJsInteropClass(ClassElement element) => isJsInterop(element);
+
+  /// Returns `true` if [element] is a JsInterop method.
+  bool isJsInteropMethod(MethodElement element) => isJsInterop(element);
+
   /// Returns `true` if the name of [element] is fixed for the generated
   /// JavaScript.
   bool hasFixedBackendName(Element element) {
     return isJsInterop(element) ||
         nativeMemberName.containsKey(element.declaration);
   }
 
   String _jsNameHelper(Element element) {
     String jsInteropName = jsInteropNames[element.declaration];
     assert(invariant(element, !(_isJsInterop(element) && jsInteropName == null),
@@ skipping 29 matching lines @@
   /// JavaScriptInterop mechanism which is allowed for user libraries.
   bool isNative(Element element) {
     if (isJsInterop(element)) return true;
     if (element.isClass) {
       return nativeClassTagInfo.containsKey(element.declaration);
     } else {
       return nativeMemberName.containsKey(element.declaration);
     }
   }
 
+  /// Returns `true` if [cls] is a native class.
+  bool isNativeClass(ClassElement element) => isNative(element);
+
+  /// Returns `true` if [element] is a native member of a native class.
+  bool isNativeMember(MemberElement element) => isNative(element);
+
   /// Returns `true` if [element] or any of its superclasses is native.
   bool isNativeOrExtendsNative(ClassElement element) {
     if (element == null) return false;
-    if (isNative(element) || isJsInterop(element)) {
+    if (isNativeClass(element) || isJsInteropClass(element)) {
       return true;
     }
     assert(element.isResolved);
     return isNativeOrExtendsNative(element.superclass);
   }
 
   /// Sets the native [name] for the member [element]. This name is used for
   /// [element] in the generated JavaScript.
   void setNativeMemberName(MemberElement element, String name) {
     // TODO(johnniwinther): Avoid setting this more than once. The enqueuer
@@ skipping 41 matching lines @@
         .where((s) => !s.startsWith('!'))
         .toList();
   }
 
   /// Returns `true` if [cls] has a `!nonleaf` tag word.
   bool hasNativeTagsForcedNonLeaf(ClassElement cls) {
     return getNativeTagsOfClassRaw(cls).contains('!nonleaf');
   }
 
   /// Returns the [NativeBehavior] for calling the native [method].
-  NativeBehavior getNativeMethodBehavior(FunctionElement method) {
+  NativeBehavior getNativeMethodBehavior(MethodElement method) {
     assert(invariant(method, nativeMethodBehavior.containsKey(method),
         message: "No native method behavior has been computed for $method."));
     return nativeMethodBehavior[method];
   }
 
   /// Returns the [NativeBehavior] for reading from the native [field].
   NativeBehavior getNativeFieldLoadBehavior(FieldElement field) {
     assert(invariant(field, nativeFieldLoadBehavior.containsKey(field),
         message: "No native field load behavior has been "
             "computed for $field."));
     return nativeFieldLoadBehavior[field];
   }
 
   /// Returns the [NativeBehavior] for writing to the native [field].
   NativeBehavior getNativeFieldStoreBehavior(FieldElement field) {
     assert(invariant(field, nativeFieldStoreBehavior.containsKey(field),
         message: "No native field store behavior has been "
             "computed for $field."));
     return nativeFieldStoreBehavior[field];
   }
 
   /// Registers the [behavior] for calling the native [method].
-  void setNativeMethodBehavior(
-      FunctionElement method, NativeBehavior behavior) {
+  void setNativeMethodBehavior(MethodElement method, NativeBehavior behavior) {
     nativeMethodBehavior[method] = behavior;
   }
 
   /// Registers the [behavior] for reading from the native [field].
   void setNativeFieldLoadBehavior(FieldElement field, NativeBehavior behavior) {
     nativeFieldLoadBehavior[field] = behavior;
   }
 
   /// Registers the [behavior] for writing to the native [field].
   void setNativeFieldStoreBehavior(
       FieldElement field, NativeBehavior behavior) {
     nativeFieldStoreBehavior[field] = behavior;
   }
 
   /// Apply JS$ escaping scheme to convert possible escaped Dart names into
   /// JS names.
   String getUnescapedJSInteropName(String name) {
     return name.startsWith(_jsInteropEscapePrefix)
         ? name.substring(_jsInteropEscapePrefix.length)
         : name;
   }
 }