[dart:js_interop] Add literal constructors for inline classes

Adds @objectliteral annotation to denote object literal constructors,
and implements it in all the backends. For dart2js, this involves
modifying the SSA and for dart2wasm, we create a one-per-shape
forwarding procedure to a specialized JS method that returns the
literal. This also modifies @anonymous semantics in dart2wasm to
be consistent with the other backends.

CoreLibraryReviewExempt: Backend-specific, just adding annotation.
Change-Id: I4d7a9ea9ed097f4f378709b40f8bd74f02e26b23
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/283922
Commit-Queue: Srujan Gaddam <srujzs@google.com>
Reviewed-by: Joshua Litt <joshualitt@google.com>

Author: srujzs

pkg/_js_interop_checks/lib/js_interop_checks.dart

@@ -318,12 +318,16 @@ class JsInteropChecks extends RecursiveVisitor {
       }
 
       // Check JS Interop positional and named parameters.
-      var isAnonymousFactory = _classHasAnonymousAnnotation && node.isFactory;
-      if (isAnonymousFactory) {
-        // ignore: unnecessary_null_comparison
-        if (node.function != null &&
-            node.function.positionalParameters.isNotEmpty) {
-          var firstPositionalParam = node.function.positionalParameters[0];
+      var isObjectLiteralFactory =
+          _classHasAnonymousAnnotation && node.isFactory ||
+              node.isInlineClassMember && hasObjectLiteralAnnotation(node);
+      if (isObjectLiteralFactory) {
+        var positionalParams = node.function.positionalParameters;
+        if (node.isInlineClassMember) {
+          positionalParams = positionalParams.skip(1).toList();
+        }
+        if (node.function.positionalParameters.isNotEmpty) {
+          var firstPositionalParam = positionalParams[0];
           _diagnosticsReporter.report(
               messageJsInteropAnonymousFactoryPositionalParameters,
               firstPositionalParam.fileOffset,

pkg/_js_interop_checks/lib/src/js_interop.dart

@@ -40,6 +40,11 @@ bool hasJSExportAnnotation(Annotatable a) =>
 bool hasNativeAnnotation(Annotatable a) =>
     a.annotations.any(_isNativeAnnotation);
 
+/// Returns true iff the node has an `@ObjectLiteral(...)` annotation from
+/// `dart:js_interop`.
+bool hasObjectLiteralAnnotation(Annotatable a) =>
+    a.annotations.any(_isObjectLiteralAnnotation);
+
 /// If [a] has a `@JS('...')` annotation, returns the value inside the
 /// parentheses.
 ///
@@ -100,6 +105,7 @@ String getJSExportName(Annotatable a) {
 final _packageJs = Uri.parse('package:js/js.dart');
 final _internalJs = Uri.parse('dart:_js_annotations');
 final _jsHelper = Uri.parse('dart:_js_helper');
+final _jsInterop = Uri.parse('dart:js_interop');
 
 /// Returns true if [value] is the interop annotation whose class is
 /// [annotationClassName] from `package:js` or from `dart:_js_annotations`.
@@ -141,6 +147,15 @@ bool _isNativeAnnotation(Expression value) {
       c.enclosingLibrary.importUri == _jsHelper;
 }
 
+/// Returns true if [value] is the `ObjectLiteral` annotation from
+/// `dart:js_interop`.
+bool _isObjectLiteralAnnotation(Expression value) {
+  var c = annotationClass(value);
+  return c != null &&
+      c.name == 'ObjectLiteral' &&
+      c.enclosingLibrary.importUri == _jsInterop;
+}
+
 /// Returns the class of the instance referred to by metadata annotation [node].
 ///
 /// For example:

pkg/_js_interop_checks/lib/src/transformations/js_util_optimizer.dart

@@ -14,6 +14,7 @@ import '../js_interop.dart'
         hasInternalJSInteropAnnotation,
         hasJSInteropAnnotation,
         hasNativeAnnotation,
+        hasObjectLiteralAnnotation,
         hasStaticInteropAnnotation,
         hasTrustTypesAnnotation;
 
@@ -174,8 +175,9 @@ class JsUtilOptimizer extends Transformer {
     if (node.isInlineClassMember) {
       var kind =
           _inlineExtensionIndex.getInlineDescriptor(node.reference)?.kind;
-      return kind == InlineClassMemberKind.Constructor ||
-          kind == InlineClassMemberKind.Factory;
+      return (kind == InlineClassMemberKind.Constructor ||
+              kind == InlineClassMemberKind.Factory) &&
+          !hasObjectLiteralAnnotation(node);
     } else {
       return node.kind == ProcedureKind.Factory &&
           node.enclosingClass != null &&

pkg/compiler/lib/src/common/names.dart

@@ -265,6 +265,9 @@ class Uris {
   static final Uri dart__js_annotations =
       Uri(scheme: 'dart', path: '_js_annotations');
 
+  /// The URI for 'dart:js_interop'.
+  static final Uri dart__js_interop = Uri(scheme: 'dart', path: 'js_interop');
+
   /// The URI for 'package:meta/dart2js.dart'.
   static final Uri package_meta_dart2js =
       Uri(scheme: 'package', path: 'meta/dart2js.dart');

pkg/compiler/lib/src/ir/annotations.dart

@@ -18,6 +18,7 @@ class IrAnnotationData {
   final Map<ir.Class, String> _jsInteropClassNames = {};
   final Set<ir.Class> _anonymousJsInteropClasses = {};
   final Map<ir.Member, String> _jsInteropMemberNames = {};
+  final Set<ir.Member> _jsInteropObjectLiterals = {};
 
   final Map<ir.Member, List<PragmaAnnotationData>> _memberPragmaAnnotations =
       {};
@@ -52,6 +53,10 @@ class IrAnnotationData {
   bool isAnonymousJsInteropClass(ir.Class node) =>
       _anonymousJsInteropClasses.contains(node);
 
+  // Returns `true` if [node] is annotated with `@ObjectLiteral`.
+  bool isJsInteropObjectLiteral(ir.Member node) =>
+      _jsInteropObjectLiterals.contains(node);
+
   // Returns the text from the `@JS(<text>)` annotation of [node], if any.
   String? getJsInteropMemberName(ir.Member node) => _jsInteropMemberNames[node];
 
@@ -74,11 +79,15 @@ class IrAnnotationData {
     });
   }
 
-  void forEachJsInteropMember(void Function(ir.Member, String?) f) {
+  void forEachJsInteropMember(
+      void Function(ir.Member, String?,
+              {required bool isJsInteropObjectLiteral})
+          f) {
     _jsInteropLibraryNames.forEach((ir.Library library, _) {
       for (ir.Member member in library.members) {
         if (member.isExternal) {
-          f(member, _jsInteropMemberNames[member] ?? member.name.text);
+          f(member, _jsInteropMemberNames[member] ?? member.name.text,
+              isJsInteropObjectLiteral: isJsInteropObjectLiteral(member));
         }
       }
     });
@@ -89,7 +98,7 @@ class IrAnnotationData {
         if (member.isExternal) {
           name ??= member.name.text;
         }
-        f(member, name);
+        f(member, name, isJsInteropObjectLiteral: false);
       }
     });
   }
@@ -142,6 +151,12 @@ IrAnnotationData processAnnotations(ModularCore modularCore) {
           data._jsInteropMemberNames[member] = jsName;
         }
 
+        bool isJsInteropObjectLiteralMember =
+            _isJsInteropObjectLiteral(constant);
+        if (isJsInteropObjectLiteralMember) {
+          data._jsInteropObjectLiterals.add(member);
+        }
+
         bool isNativeMember = _isNativeMember(constant);
         if (isNativeMember) {
           data._nativeMembers.add(member);
@@ -318,6 +333,12 @@ bool _isAnonymousJsInterop(ir.Constant constant) {
               Uris.dart__js_annotations);
 }
 
+bool _isJsInteropObjectLiteral(ir.Constant constant) {
+  return constant is ir.InstanceConstant &&
+      constant.classNode.name == 'ObjectLiteral' &&
+      constant.classNode.enclosingLibrary.importUri == Uris.dart__js_interop;
+}
+
 class PragmaAnnotationData {
   // TODO(johnniwinther): Support non 'dart2js:' pragma names if necessary.
   final String suffix;

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

@@ -35,6 +35,9 @@ class NativeBasicDataBuilder {
   /// The JavaScript members implemented via typed JavaScript interop.
   final Map<MemberEntity, String> _jsInteropMembers = {};
 
+  /// The JavaScript interop members annotated with `@ObjectLiteral`.
+  final Set<MemberEntity> _jsInteropObjectLiterals = {};
+
   /// Sets the native tag info for [cls].
   ///
   /// The tag info string contains comma-separated 'words' which are either
@@ -99,14 +102,16 @@ class NativeBasicDataBuilder {
 
   /// 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) {
+  void markAsJsInteropMember(MemberEntity element, String name,
+      {required bool isJsInteropObjectLiteral}) {
     assert(
         !_closed,
         failedAt(
             element,
             "NativeBasicDataBuilder is closed. "
             "Trying to mark $element as a js-interop member."));
     _jsInteropMembers[element] = name;
+    if (isJsInteropObjectLiteral) _jsInteropObjectLiterals.add(element);
   }
 
   /// Creates the [NativeBasicData] object for the data collected in this
@@ -120,7 +125,8 @@ class NativeBasicDataBuilder {
         _jsInteropLibraries,
         _jsInteropClasses,
         _anonymousJsInteropClasses,
-        _jsInteropMembers);
+        _jsInteropMembers,
+        _jsInteropObjectLiterals);
   }
 
   void reopenForTesting() {
@@ -156,14 +162,18 @@ class NativeBasicData {
   /// The JavaScript members implemented via typed JavaScript interop.
   final Map<MemberEntity, String?> _jsInteropMembers;
 
+  /// JavaScript interop constructors annotated with `@ObjectLiteral`.
+  final Set<MemberEntity> _jsInteropObjectLiterals;
+
   NativeBasicData(
       this._env,
       this._isAllowInteropUsed,
       this._nativeClassTagInfo,
       this._jsInteropLibraries,
       this._jsInteropClasses,
       this._anonymousJsInteropClasses,
-      this._jsInteropMembers);
+      this._jsInteropMembers,
+      this._jsInteropObjectLiterals);
 
   factory NativeBasicData.fromIr(
       KernelToElementMap map, IrAnnotationData data) {
@@ -173,6 +183,7 @@ class NativeBasicData {
     Map<ClassEntity, String> jsInteropClasses = {};
     Set<ClassEntity> anonymousJsInteropClasses = {};
     Map<MemberEntity, String?> jsInteropMembers = {};
+    Set<MemberEntity> jsInteropObjectLiterals = {};
 
     data.forEachNativeClass((ir.Class node, String text) {
       nativeClassTagInfo[map.getClass(node)] = NativeClassTag(text);
@@ -189,17 +200,27 @@ class NativeBasicData {
         anonymousJsInteropClasses.add(cls);
       }
     });
-    data.forEachJsInteropMember((ir.Member node, String? name) {
+    data.forEachJsInteropMember((ir.Member node, String? name,
+        {required bool isJsInteropObjectLiteral}) {
       // TODO(49428): Are there other members that we should ignore here?
       //  There are non-external and unannotated members because the source code
       //  doesn't contain them. (e.g. default constructor) Does it make sense to
       //  consider these valid JS members?
       if (memberIsIgnorable(node)) return;
       jsInteropMembers[map.getMember(node)] = name;
+      if (isJsInteropObjectLiteral)
+        jsInteropObjectLiterals.add(map.getMember(node));
     });
 
-    return NativeBasicData(env, false, nativeClassTagInfo, jsInteropLibraries,
-        jsInteropClasses, anonymousJsInteropClasses, jsInteropMembers);
+    return NativeBasicData(
+        env,
+        false,
+        nativeClassTagInfo,
+        jsInteropLibraries,
+        jsInteropClasses,
+        anonymousJsInteropClasses,
+        jsInteropMembers,
+        jsInteropObjectLiterals);
   }
 
   /// Deserializes a [NativeBasicData] object from [source].
@@ -220,6 +241,7 @@ class NativeBasicData {
     Set<ClassEntity> anonymousJsInteropClasses = source.readClasses().toSet();
     Map<MemberEntity, String?> jsInteropMembers = source
         .readMemberMap((MemberEntity member) => source.readStringOrNull());
+    Set<MemberEntity> jsInteropObjectLiterals = source.readMembers().toSet();
     source.end(tag);
     return NativeBasicData(
         elementEnvironment,
@@ -228,7 +250,8 @@ class NativeBasicData {
         jsInteropLibraries,
         jsInteropClasses,
         anonymousJsInteropClasses,
-        jsInteropMembers);
+        jsInteropMembers,
+        jsInteropObjectLiterals);
   }
 
   /// Serializes this [NativeBasicData] to [sink].
@@ -244,6 +267,7 @@ class NativeBasicData {
     sink.writeClasses(_anonymousJsInteropClasses);
     sink.writeMemberMap(_jsInteropMembers,
         (MemberEntity member, String? name) => sink.writeStringOrNull(name));
+    sink.writeMembers(_jsInteropObjectLiterals);
     sink.end(tag);
   }
 
@@ -348,14 +372,17 @@ class NativeBasicData {
         map.toBackendClassSet(_anonymousJsInteropClasses);
     Map<MemberEntity, String?> jsInteropMembers =
         map.toBackendMemberMap(_jsInteropMembers, identity);
+    Set<MemberEntity> jsInteropObjectLiterals =
+        map.toBackendMemberSet(_jsInteropObjectLiterals);
     return NativeBasicData(
         environment,
         isAllowInteropUsed,
         nativeClassTagInfo,
         jsInteropLibraries,
         jsInteropClasses,
         anonymousJsInteropClasses,
-        jsInteropMembers);
+        jsInteropMembers,
+        jsInteropObjectLiterals);
   }
 }
 
@@ -569,11 +596,20 @@ class NativeData implements NativeBasicData {
   Map<MemberEntity, String?> get _jsInteropMembers =>
       _nativeBasicData._jsInteropMembers;
 
+  @override
+  Set<MemberEntity> get _jsInteropObjectLiterals =>
+      _nativeBasicData._jsInteropObjectLiterals;
+
   /// Returns `true` if [element] has an `@Anonymous` annotation.
   bool isAnonymousJsInteropClass(ClassEntity element) {
     return _anonymousJsInteropClasses.contains(element);
   }
 
+  /// Returns `true` if [element] has an `@ObjectLiteral` annotation.
+  bool isJsInteropObjectLiteral(MemberEntity element) {
+    return _jsInteropObjectLiterals.contains(element);
+  }
+
   @override
   bool isNativeClass(ClassEntity element) =>
       _nativeBasicData.isNativeClass(element);

pkg/compiler/lib/src/kernel/native_basic_data.dart

@@ -86,7 +86,9 @@ class KernelAnnotationProcessor {
             /*reporter.reportErrorMessage(
                 function, MessageKind.JS_INTEROP_NON_EXTERNAL_MEMBER);*/
           } else {
-            _nativeBasicDataBuilder.markAsJsInteropMember(function, memberName);
+            _nativeBasicDataBuilder.markAsJsInteropMember(function, memberName,
+                isJsInteropObjectLiteral:
+                    annotationData.isJsInteropObjectLiteral(memberNode));
             // TODO(johnniwinther): It is unclear whether library can be
             // implicitly js-interop. For now we allow it.
             isJsLibrary = true;
@@ -128,7 +130,8 @@ class KernelAnnotationProcessor {
               // TODO(johnniwinther): The documentation states that explicit
               // member name annotations are not allowed on instance members.
               _nativeBasicDataBuilder.markAsJsInteropMember(
-                  function, memberName);
+                  function, memberName,
+                  isJsInteropObjectLiteral: false);
             }
           }
         });
@@ -145,7 +148,8 @@ class KernelAnnotationProcessor {
             // TODO(johnniwinther): The documentation states that explicit
             // member name annotations are not allowed on instance members.
             _nativeBasicDataBuilder.markAsJsInteropMember(
-                constructor, memberName);
+                constructor, memberName,
+                isJsInteropObjectLiteral: false);
           }
         });
       }