[dart2wasm] Use shared closure argument dispatchers for dynamic call entries

This removes 4591 functions from ACX gallery main module
which translates to -43 KB / -1.6% (-3.5% code section)

We have already today a callsite guarantee that the closure call
(type, positional, named) arguments are valid arguments to the
target closure (they also have the right type).

That means the `closure.vtable.dynamicCall` entry's only purpose
is to unpack the (type, positional, named) argument arrays and call
the target.

Instead of calling the target directly (as we did so far) we now
unpack argument arrays and call the right vtable entry. This logic
can be shared amongst all closures of the same representation and
therefore leads to big reduction in wasm functions.

=> We do that in this CL.

There's two exceptions to this:

* In dynamic module scenario we don't have closed-world knowledge
  of closure definitions & closure call site. There's no specific
  vtable entries for positional+name combinations we could forward
  to.

* In closed world scenario where there's a usage of `Function.apply`
  with named arguments: We don't generate vtable entries for all
  possible name combinations a closure can be called with.

So we change the closure layouter algorithm to find out if there's
a usage of `Function.apply` with named arguments.

A few tangential changes:

* Fix a bug revealed by this change: The static tearoff
  instantiation constant's dynamic call entry must pass the generic
  closure object when calling the generic closure.
  => The shared dynamic call entry dispatchers will now verify
     (in assertion) mode the assumptions, which revealed this issue

* The closure layouter algorithm will now consider `obj.foo(a: ...)`
  as a potential dynamic call site (due to call-via-field) and
  therefore record the name combinations used there
  => Tested via `web/wasm/closures/dynamic_call_via_field_test`

We test the optimization by checking in 3 tests that show what
ends up in the vtables:

* `pkg/dart2wasm/test/ir_tests/dyn_closure.dart`
  => uses dynamic calls
  => dynamic call entries are "closure arguments dispatcher"

* `pkg/dart2wasm/test/ir_tests/dyn_closure_function_apply.dart`
  => uses Function.apply without names
  => dynamic call entries are "closure arguments dispatcher"

* `pkg/dart2wasm/test/ir_tests/dyn_closure_function_apply_named.dart`
  => uses Function.apply with named arguments
  => dynamic call entries are closure specific

Issue #60458

Change-Id: I099984b542b05920b02596410a1bf6a08d2a0302
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/460080
Reviewed-by: Ömer Ağacan <[email protected]>

Author: mkustermann

pkg/dart2wasm/lib/closures.dart

@@ -59,10 +59,12 @@ class ClosureImplementation {
 /// an entry for each (non-empty) combination of argument names that closures
 /// with this layout can be called with.
 class ClosureRepresentation {
-  /// The struct field index in the vtable struct at which the function
-  /// entries start.
+  /// The number of type arguments.
   final int typeCount;
 
+  /// The maximum number of positional parameters.
+  final int maxPositionalCount;
+
   /// The Wasm struct type for the vtable.
   final w.StructType vtableStruct;
 
@@ -129,13 +131,16 @@ class ClosureRepresentation {
   ClosureRepresentation(
       Translator translator,
       this.typeCount,
+      this.maxPositionalCount,
       this.vtableStruct,
       this.closureStruct,
       this._indexOfCombination,
       this.instantiationContextStruct);
 
   bool get isGeneric => typeCount > 0;
 
+  bool get hasNamed => _indexOfCombination != null;
+
   /// Where the vtable entries for function calls start in the vtable struct.
   int get vtableBaseIndex => isGeneric
       ? ClosureLayouter.vtableBaseIndexGeneric
@@ -216,6 +221,10 @@ class ClosureLayouter extends RecursiveVisitor {
   // The member currently being visited while collecting function signatures.
   Member? currentMember;
 
+  /// Whether the kernel [Component] uses `Function.apply` and possibly passes
+  /// non-empty map for named arguments.
+  late bool usesFunctionApplyWithNamedArguments;
+
   // For non-generic closures. The entries are:
   // 0: Dynamic call entry
   // 1-...: Entries for calling the closure
@@ -400,8 +409,9 @@ class ClosureLayouter extends RecursiveVisitor {
             (translator.component.metadata["vm.procedure-attributes.metadata"]
                     as ProcedureAttributesMetadataRepository)
                 .mapping;
-
   void collect() {
+    usesFunctionApplyWithNamedArguments = false;
+
     // Dynamic module enabled builds use dynamic call entry points for all
     // closure invocations so we don't need to generate any representation
     // info.
@@ -478,12 +488,12 @@ class ClosureLayouter extends RecursiveVisitor {
 
   ClosureRepresentation _createRepresentation(
       int typeCount,
-      int positionalCount,
+      int maxPositionalCount,
       List<String> names,
       ClosureRepresentation? parent,
       Map<NameCombination, int>? indexOfCombination,
       Iterable<int> paramCounts) {
-    List<String> nameTags = ["$typeCount", "$positionalCount", ...names];
+    List<String> nameTags = ["$typeCount", "$maxPositionalCount", ...names];
     String vtableName = ["#Vtable", ...nameTags].join("-");
     String closureName = ["#Closure", ...nameTags].join("-");
     w.StructType parentVtableStruct = parent?.vtableStruct ??
@@ -508,7 +518,7 @@ class ClosureLayouter extends RecursiveVisitor {
     if (typeCount > 0) {
       // Add or set vtable field for the instantiation function.
       instantiatedRepresentation =
-          getClosureRepresentation(0, positionalCount, names)!;
+          getClosureRepresentation(0, maxPositionalCount, names)!;
       w.RefType inputType = w.RefType.def(closureBaseStruct, nullable: false);
       w.RefType outputType = w.RefType.def(
           instantiatedRepresentation.closureStruct,
@@ -564,6 +574,7 @@ class ClosureLayouter extends RecursiveVisitor {
     ClosureRepresentation representation = ClosureRepresentation(
         translator,
         typeCount,
+        maxPositionalCount,
         vtableStruct,
         closureStruct,
         indexOfCombination,
@@ -618,7 +629,7 @@ class ClosureLayouter extends RecursiveVisitor {
                     vtableBaseIndexNonGeneric + instantiationTrampolines.length,
                     vtableStruct,
                     vtableBaseIndexGeneric +
-                        (positionalCount + 1) +
+                        (maxPositionalCount + 1) +
                         genericIndex)
                 : translator
                     .getDummyValuesCollectorForModule(module)
@@ -1008,8 +1019,27 @@ class ClosureLayouter extends RecursiveVisitor {
     currentMember = null;
   }
 
+  @override
+  void visitStaticInvocation(StaticInvocation node) {
+    super.visitStaticInvocation(node);
+    if (node.target == translator.functionApply) {
+      // Function.apply(function, positionalArguments, [namedArguments])
+      if (node.arguments.positional.length > 2) {
+        usesFunctionApplyWithNamedArguments = true;
+      }
+    }
+  }
+
+  @override
+  void visitStaticTearOff(StaticTearOff node) {
+    visitStaticTearOffConstantReference(StaticTearOffConstant(node.target));
+  }
+
   @override
   void visitStaticTearOffConstantReference(StaticTearOffConstant constant) {
+    if (constant.target == translator.functionApply) {
+      usesFunctionApplyWithNamedArguments = true;
+    }
     _visitFunctionNode(constant.function);
   }
 
@@ -1028,9 +1058,23 @@ class ClosureLayouter extends RecursiveVisitor {
 
   @override
   void visitDynamicInvocation(DynamicInvocation node) {
-    if (node.name.text == "call") {
-      _visitFunctionInvocation(node.arguments);
-    }
+    // NOTE: One may have two different kinds of calls here:
+    // ```
+    //   dynamic x;
+    //   x(namedArg: 1);
+    //   x.foo(namedArg: 1);
+    // ```
+    // It may appear as we only have to handle the first case, namely
+    // `node.name.text == "call"`, but the second case can also be a
+    // dynamic closure callsite via call-through-field:
+    // ```
+    //   class Foo {
+    //     void Function({int? namedArg}) get foo => ...;
+    //   }
+    // ```
+    // then a `x.foo(namedArg: 1)` will be executed at runtime via
+    // `var tmp = x.foo; tmp(namedArg: 1)`.
+    _visitFunctionInvocation(node.arguments);
     super.visitDynamicInvocation(node);
   }
 }

pkg/dart2wasm/lib/constants.dart

@@ -1180,12 +1180,12 @@ class ConstantCreator extends ConstantVisitor<ConstantInfo?>
 
         final b = function.body;
 
-        final closureLocal = function.locals[0];
         final typeArgsListLocal = function.locals[1]; // empty
         final posArgsListLocal = function.locals[2];
         final namedArgsListLocal = function.locals[3];
 
-        b.local_get(closureLocal);
+        constants.instantiateConstant(
+            b, tearOffConstantInfo.constant, translator.topTypeNonNullable);
         constants.instantiateConstant(
             b, typeArgsArrayConstantInfo.constant, typeArgsListLocal.type);
         b.local_get(posArgsListLocal);

pkg/dart2wasm/lib/intrinsics.dart

@@ -2021,7 +2021,7 @@ class Intrinsifier {
         b.end();
         b.local_set(posArgsLocal);
 
-        // Convert named argument map to list, to be passed to shape and type
+        // Convert named argument map to array, to be passed to shape and type
         // checkers and the dynamic call entry.
         final namedArgsListLocal =
             b.addLocal(translator.nullableObjectArrayTypeRef);

pkg/dart2wasm/lib/kernel_nodes.dart

@@ -276,6 +276,8 @@ mixin KernelNodes {
       index.getTopLevelProcedure("dart:core", "_runtimeTypeEquals");
   late final Procedure runtimeTypeHashCode =
       index.getTopLevelProcedure("dart:core", "_runtimeTypeHashCode");
+  late final Procedure? functionApply =
+      index.tryGetProcedure('dart:core', 'Function', 'apply');
 
   // dart:core invocation/exception procedures
   late final Procedure invocationGetterFactory =