[ddc] Add JSInterop support in the new type system

nshahan · Commit Queue · commit ce9b44e6045a · 2023-06-08T23:00:40.000Z
Encodes the necessary type rules and adds type identifier tags to support the legacy JavaScript interop behavior. Issue: #48585 Change-Id: I933db1c9899711898fb829821f3e051043f33be2 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/305845 Reviewed-by: Srujan Gaddam <srujzs@google.com> Commit-Queue: Nicholas Shahan <nshahan@google.com> Reviewed-by: Mayank Patke <fishythefish@google.com>
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -524,14 +524,54 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       }
       var universeClass =
           rtiLibrary.classes.firstWhere((cls) => cls.name == '_Universe');
-      var typeRules = _typeRecipeGenerator.visitedInterfaceTypeRules;
-      var template = "#._Universe.#(#, JSON.parse('${jsonEncode(typeRules)}'))";
-      var addRulesStatement = js.call(template, [
-        emitLibraryName(rtiLibrary),
-        _emitMemberName('addRules', memberClass: universeClass),
-        runtimeCall('typeUniverse')
-      ]).toStatement();
-      moduleItems.add(addRulesStatement);
+      var typeRules = _typeRecipeGenerator.liveInterfaceTypeRules;
+      if (typeRules.isNotEmpty) {
+        var template = '#._Universe.#(#, JSON.parse(#))';
+        var addRulesStatement = js.call(template, [
+          emitLibraryName(rtiLibrary),
+          _emitMemberName('addRules', memberClass: universeClass),
+          runtimeCall('typeUniverse'),
+          js.string(jsonEncode(typeRules), "'")
+        ]).toStatement();
+        moduleItems.add(addRulesStatement);
+      }
+      // Update type rules for `LegacyJavaScriptObject` to add all interop
+      // types in this module as a supertype.
+      var updateRules = _typeRecipeGenerator.updateLegacyJavaScriptObjectRules;
+      if (updateRules.isNotEmpty) {
+        // All JavaScript interop classes should be mutual subtypes with
+        // `LegacyJavaScriptObject`. To achieve this the rules are manually
+        // added here. There is special redirecting rule logic in the dart:_rti
+        // library for interop types because otherwise they would duplicate
+        // a lot of supertype information.
+        var updateRulesStatement =
+            js.statement('#._Universe.#(#, JSON.parse(#))', [
+          emitLibraryName(rtiLibrary),
+          _emitMemberName('addOrUpdateRules', memberClass: universeClass),
+          runtimeCall('typeUniverse'),
+          js.string(jsonEncode(updateRules), "'")
+        ]);
+        moduleItems.add(updateRulesStatement);
+      }
+      var jsInteropTypeRecipes =
+          _typeRecipeGenerator.visitedJsInteropTypeRecipes;
+      if (jsInteropTypeRecipes.isNotEmpty) {
+        // Update the `LegacyJavaScriptObject` class with the type tags for all
+        // interop types in this module. This is the quick path for simple type
+        // tests that matches the rules encoded above.
+        var legacyJavaScriptObjectClass = _coreTypes.index
+            .getClass('dart:_interceptors', 'LegacyJavaScriptObject');
+        var legacyJavaScriptObjectClassRef = _emitClassRef(
+            legacyJavaScriptObjectClass.getThisType(
+                _coreTypes, Nullability.nonNullable));
+        var interopRecipesArray = js_ast.stringArray([
+          _typeRecipeGenerator.interfaceTypeRecipe(legacyJavaScriptObjectClass),
+          ...jsInteropTypeRecipes
+        ]);
+        var jsInteropRules = runtimeStatement('addRtiResources(#, #)',
+            [legacyJavaScriptObjectClassRef, interopRecipesArray]);
+        moduleItems.add(jsInteropRules);
+      }
     }
 
     // Visit directives (for exports)
@@ -6043,6 +6083,10 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       }
 
       if (args.length == 1) {
+        if (name == 'getInterceptor') {
+          var argExpression = args.single.accept(this);
+          return runtimeCall('getInterceptorForRti(#)', [argExpression]);
+        }
         if (name == 'JS_GET_NAME') {
           var staticGet = args.single as StaticGet;
           var enumField = staticGet.target as Field;
diff --git a/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart b/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart
@@ -12,6 +12,7 @@ import 'package:path/path.dart' as p;
 
 import '../compiler/js_names.dart';
 import 'future_or_normalizer.dart';
+import 'js_interop.dart';
 import 'kernel_helpers.dart';
 import 'type_environment.dart';
 
@@ -64,6 +65,9 @@ class TypeRecipeGenerator {
   /// Returns a mapping of type hierarchies for all [InterfaceType]s that have
   /// appeared in type recipes.
   ///
+  /// While the value of the returned map is typed as `Object` it is always
+  /// either a `String` or a `Map<String, List<String>>`.
+  ///
   /// This mapping is intended to satisfy the requirements for the
   /// `_Universe.addRules()` static method in the runtime rti library.
   ///
@@ -78,11 +82,35 @@ class TypeRecipeGenerator {
   ///   "type n": {...}}'
   /// ```
   ///
+  /// Additionally, the runtime rti library supports a special forwarding rule
+  /// for non-static JavaScript interop types. With this format every interop
+  /// type simply forwards to `LegacyJavaScriptObject` where they all share
+  /// a single type rule
+  ///
+  /// ```
+  /// '{"interop type 0": "LegacyJavaScriptObject",
+  ///    ...
+  ///   "interop type n": "LegacyJavaScriptObject"}'
+  /// ```
+  ///
   /// It is expected that this method is called at the end of a compilation
   /// after all types used in the module have already been visited. Otherwise
   /// the results will be incomplete.
-  Map<String, Map<String, List<String>>> get visitedInterfaceTypeRules {
-    var rules = <String, Map<String, List<String>>>{};
+  Map<String, Object> get liveInterfaceTypeRules {
+    // All non-static JavaScript interop classes should be mutual subtypes with
+    // 'LegacyJavaScriptObject`. To achieve this the rules are manually
+    // added here. There is special redirecting rule logic in the dart:_rti
+    // library for interop types because otherwise they would duplicate
+    // a lot of supertype information.
+    var legacyJavaScriptObjectRecipe = interfaceTypeRecipe(_coreTypes.index
+        .getClass('dart:_interceptors', 'LegacyJavaScriptObject'));
+    var rules = <String, Object>{
+      for (var recipe in visitedJsInteropTypeRecipes)
+        recipe: legacyJavaScriptObjectRecipe
+    };
+
+    // All Dart types hierarchy rules are generated by exploring their class
+    // hierarchy.
     for (var type in _recipeVisitor.visitedInterfaceTypes) {
       var recipe = interfaceTypeRecipe(type.classNode);
       var cls = type.classNode;
@@ -121,8 +149,30 @@ class TypeRecipeGenerator {
     return rules;
   }
 
+  /// Returns a mapping of type hierarchies for all [InterfaceType]s that have
+  /// appeared in type recipes.
+  Map<String, Object> get updateLegacyJavaScriptObjectRules {
+    var recipes = visitedJsInteropTypeRecipes;
+    return {
+      if (recipes.isNotEmpty)
+        interfaceTypeRecipe(_coreTypes.index
+                .getClass('dart:_interceptors', 'LegacyJavaScriptObject')):
+            // Update type rules for `LegacyJavaScriptObject` to add all interop
+            // types in this module as a supertype.
+            {
+          for (var interopType in _recipeVisitor._visitedJsInteropTypes)
+            interfaceTypeRecipe(interopType.classNode): _recipeVisitor
+                ._listOfJSAnyType(interopType.typeArguments.length)
+        }
+    };
+  }
+
   String interfaceTypeRecipe(Class node) =>
       _recipeVisitor.interfaceTypeRecipe(node);
+
+  Iterable<String> get visitedJsInteropTypeRecipes =>
+      _recipeVisitor.visitedJsInteropTypes
+          .map((type) => interfaceTypeRecipe(type.classNode));
 }
 
 /// A visitor to generate type recipe strings from a [DartType].
@@ -155,6 +205,7 @@ class _TypeRecipeVisitor extends DartTypeVisitor<String> {
 
   /// All of the [InterfaceType]s visited.
   final _visitedInterfaceTypes = <InterfaceType>{};
+  final _visitedJsInteropTypes = <InterfaceType>{};
   final CoreTypes _coreTypes;
 
   _TypeRecipeVisitor(this._typeEnvironment, this._coreTypes);
@@ -176,6 +227,10 @@ class _TypeRecipeVisitor extends DartTypeVisitor<String> {
   Iterable<InterfaceType> get visitedInterfaceTypes =>
       Set.unmodifiable(_visitedInterfaceTypes);
 
+  /// The JavaScript interop types that have been visited.
+  Iterable<InterfaceType> get visitedJsInteropTypes =>
+      Set.unmodifiable(_visitedJsInteropTypes);
+
   @override
   String defaultDartType(DartType node) =>
       throw UnimplementedError('Unknown DartType: $node');
@@ -188,15 +243,17 @@ class _TypeRecipeVisitor extends DartTypeVisitor<String> {
 
   @override
   String visitInterfaceType(InterfaceType node) {
+    var cls = node.classNode;
     addLiveType(node);
     // Generate the interface type recipe.
-    var recipeBuffer = StringBuffer(interfaceTypeRecipe(node.classNode));
+    var recipeBuffer = StringBuffer(interfaceTypeRecipe(cls));
     // Generate the recipes for all type arguments.
     if (node.typeArguments.isNotEmpty) {
+      var argumentRecipes = hasJSInteropAnnotation(cls)
+          ? _listOfJSAnyType(node.typeArguments.length)
+          : node.typeArguments.map((typeArgument) => typeArgument.accept(this));
       recipeBuffer.write(Recipe.startTypeArgumentsString);
-      recipeBuffer.writeAll(
-          node.typeArguments.map((typeArgument) => typeArgument.accept(this)),
-          Recipe.separatorString);
+      recipeBuffer.writeAll(argumentRecipes, Recipe.separatorString);
       recipeBuffer.write(Recipe.endTypeArgumentsString);
     }
     // Add nullability.
@@ -370,6 +427,17 @@ class _TypeRecipeVisitor extends DartTypeVisitor<String> {
     }
   }
 
+  /// Returns a list containing [n] copies of the "any" type recipe.
+  ///
+  /// Used exclusively for the type arguments of the older package:js style
+  /// JavaScript interop types when they are defined with generic type
+  /// parameters. These are not used to support the newer static JavaScript
+  /// interop.
+  List<String> _listOfJSAnyType(int n) => n == 0
+      ? const []
+      : List.filled(
+          n, '${Recipe.pushAnyExtensionString}${Recipe.extensionOpString}');
+
   /// Manually record [type] as being "live" without generating a recipe.
   ///
   /// "Live" types here refer to the interface types that could potentially flow
@@ -393,7 +461,9 @@ class _TypeRecipeVisitor extends DartTypeVisitor<String> {
       var cls = type.classNode;
       var typeWithoutNullability =
           cls.getThisType(_coreTypes, Nullability.nonNullable);
-      _visitedInterfaceTypes.add(typeWithoutNullability);
+      hasJSInteropAnnotation(cls)
+          ? _visitedJsInteropTypes.add(typeWithoutNullability)
+          : _visitedInterfaceTypes.add(typeWithoutNullability);
     }
   }
 }
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/operations.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/operations.dart
@@ -58,13 +58,17 @@ bind(obj, name, method) {
   var objType = getType(obj);
   var methodType = getMethodType(objType, name);
   if (JS_GET_FLAG('NEW_RUNTIME_TYPES')) {
-    if (rti.isGenericFunctionType(methodType)) {
-      // Attach the default type argument values to the new function in case
-      // they are needed for a dynamic call.
-      var defaultTypeArgs = getMethodDefaultTypeArgs(objType, name);
-      JS('', '#._defaultTypeArgs = #', f, defaultTypeArgs);
+    // Native JavaScript methods do not have Dart signatures attached that need
+    // to be copied.
+    if (methodType != null) {
+      if (rti.isGenericFunctionType(methodType)) {
+        // Attach the default type argument values to the new function in case
+        // they are needed for a dynamic call.
+        var defaultTypeArgs = getMethodDefaultTypeArgs(objType, name);
+        JS('', '#._defaultTypeArgs = #', f, defaultTypeArgs);
+      }
+      JS('', '#[#] = #', f, JS_GET_NAME(JsGetName.SIGNATURE_NAME), methodType);
     }
-    JS('', '#[#] = #', f, JS_GET_NAME(JsGetName.SIGNATURE_NAME), methodType);
   } else {
     JS('', '#[#] = #', f, _runtimeType, methodType);
   }
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/rtti.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/rtti.dart
@@ -120,6 +120,8 @@ RecordType getRecordType(RecordImpl obj) {
 }
 
 /// Returns the interceptor for [obj] as needed by the dart:rti library.
+///
+/// Calls to this method are generated by the compiler.
 @notNull
 Object getInterceptorForRti(obj) {
   var classRef;
@@ -134,13 +136,19 @@ Object getInterceptorForRti(obj) {
       case 'function':
         var signature =
             JS('', '#[#]', obj, JS_GET_NAME(JsGetName.SIGNATURE_NAME));
-        if (signature != null) classRef = JS_CLASS_REF(Function);
+        classRef = signature != null
+            ? JS_CLASS_REF(Function)
+            // Dart functions should always be tagged with a signature, assume
+            // this must be a JavaScript function.
+            : JS_CLASS_REF(JavaScriptFunction);
         break;
       default:
         // The interceptors for native JavaScript types like bool, string, etc.
         // (excluding number and function, see above) are stored as a symbolized
         // property and can be accessed from the native value itself.
         classRef = JS('', '#[#]', obj, _extensionType);
+        // If there is no extension type then this object must not be from Dart.
+        if (classRef == null) classRef = JS_CLASS_REF(LegacyJavaScriptObject);
     }
   }
   if (classRef == null) throw 'Unknown interceptor for object: ($obj)';
@@ -170,8 +178,7 @@ getReifiedType(obj) {
         var signature =
             JS('', '#[#]', obj, JS_GET_NAME(JsGetName.SIGNATURE_NAME));
         if (signature != null) return signature;
-        // TODO(nshahan) Handle JS interop functions.
-        throw "Unknown function type";
+        return typeRep<JavaScriptFunction>();
       case "undefined":
         return typeRep<Null>();
       case "number":
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/runtime.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/runtime.dart
@@ -21,6 +21,7 @@ import 'dart:_foreign_helper'
         spread;
 import 'dart:_interceptors'
     show
+        JavaScriptFunction,
         JSArray,
         JSInt,
         jsNull,
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/types.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/types.dart
@@ -184,13 +184,20 @@ class DynamicType extends DartType {
 }
 
 @notNull
-bool _isJsObject(obj) =>
-    JS('!', '# === #', getReifiedType(obj), typeRep<LegacyJavaScriptObject>());
+bool _isJsObject(obj) => JS_GET_FLAG("NEW_RUNTIME_TYPES")
+    ? obj is LegacyJavaScriptObject
+    : JS(
+        '!', '# === #', getReifiedType(obj), typeRep<LegacyJavaScriptObject>());
 
-/// Asserts that [f] is a native JS functions and returns it if so.
+/// Asserts that [f] is a native JS function and returns it if so.
 ///
 /// This function should be used to ensure that a function is a native JS
 /// function before it is passed to native JS code.
+///
+/// NOTE: The generic type argument bound is not enforced due to the
+/// `@NoReifyGeneric` annotation. In practice values of other types are passed
+/// as [f]. All non-function values are allowed to pass through as well and
+/// are returned without error.
 @NoReifyGeneric()
 F assertInterop<F extends Function?>(F f) {
   assert(
@@ -202,7 +209,13 @@ F assertInterop<F extends Function?>(F f) {
 
 bool isDartFunction(obj) =>
     JS<bool>('!', '# instanceof Function', obj) &&
-    JS<bool>('!', '#[#] != null', obj, _runtimeType);
+    JS<bool>(
+        '!',
+        '#[#] != null',
+        obj,
+        JS_GET_FLAG("NEW_RUNTIME_TYPES")
+            ? JS_GET_NAME(JsGetName.SIGNATURE_NAME)
+            : _runtimeType);
 
 Expando<Function> _assertInteropExpando = Expando<Function>();
 
diff --git a/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart b/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart
@@ -297,10 +297,11 @@ external JS_EMBEDDED_GLOBAL(String typeDescription, String name);
 external JS_BUILTIN(String typeDescription, JsBuiltin builtin,
     [arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11]);
 
-/// Returns the interceptor for [object].
+/// Returns the interceptor for [object] as needed by the dart:rti library.
 ///
-// TODO(nshahan) Replace calls at compile time?
-Object getInterceptor(obj) => dart.getInterceptorForRti(obj);
+/// Calls to this method are replaced with `getInterceptorForRti()`.
+@notNull
+external Object getInterceptor(obj);
 
 /// Returns the Rti object for the type for JavaScript arrays via JS-interop.
 ///
diff --git a/sdk/lib/_internal/js_dev_runtime/private/interceptors.dart b/sdk/lib/_internal/js_dev_runtime/private/interceptors.dart
@@ -312,5 +312,9 @@ setDispatchProperty(object, value) {}
 // all web tests.
 findInterceptorForType(Type? type) {}
 
-// TODO(nshahan) Find a correct representation for JS functions.
-typedef JavaScriptFunction = dart.FunctionType;
+/// Interceptor class for JavaScript function objects and Dart functions that
+/// have been converted to JavaScript functions.
+///
+/// A reference to this class is only used by `getInterceptor()` to return to
+/// the dart:rti library because stores information used for type checks.
+class JavaScriptFunction extends LegacyJavaScriptObject implements Function {}
diff --git a/sdk/lib/_internal/js_shared/lib/rti.dart b/sdk/lib/_internal/js_shared/lib/rti.dart
