[dart2wasm] Implement missing features in dynamic invocations:

This reimplements dynamic call code generation to add support for type
checking, named parameters (optional and required), and fixes a few
related bugs on the way.

Currently we do not try to be as efficient as possible. The goal with
this patch to implement it correctly.

Summary of the changes:

- For every dynamic access kind and member name, we generate a new
  "forwarder" function. Dynamic gets, sets, and invocations are compiled
  to calls to the forwarders with the right access kind (invocation,
  get, set) and member name.

  For example, if the program has dynamic invocation of a member "f", we
  create an "invocation forwarder for f". If it has a dynamic get of a
  member "x", we generate "getter forwarder for x".

- Forwarder functions take 4 arguments:

  - Receiver of the invocation, get, or set.

  - A Dart list for type arguments in the invocation. For gets and sets
    the list is empty.

  - A Dart list for positional arguments in the invocation. For gets the
    list is empty. For sets, the list only has one element.

  - A Dart list for named arguments. For gets and sets the list is
    empty. The list has alternating elements of type `Symbol` and
    `Object?`, for the name and value of the named parameters.

- A forwarder function compares receiver class ID with the potential
  targets of the call. When it finds a match, if compares the callee
  "shape" with the parameters passed in the call site.

  As it compares the shapes it adjusts argument lists:

  - Creates default values for missing optional and named arguments

  - Reorders the named argument list to match order expected by the
    callee

  If it can't find a matching class ID and a member with the right name
  and shape, it calls `noSuchMethod` on the receiver.

  If it finds a matching class ID and a member, it calls the "type
  checker" for the member, passing the original receiver and adjusted
  argument lists.

- A "type checker" implements argument type checking for a member, and
  it's a member of the same class as the member it's checking types
  for. This is to allow accessing class-bound type parameters when
  generating type checking code.

- Type checking is implemented using `_isSubtype` on arguments in the
  lists.

- When type checking is successful a type checker calls the original
  member, passing the arguments as expected by the member.

  If type checking is unsuccessful it throws a type error.

Most of the changes are for generating Wasm functions that compare
shapes, adjusts argument lists, and checks types.

Changes to members:

- `Translator.dynamics` fields is renamed to `Translator.forwarders`

- New field `Translator.forwarderFunctionType` added for the Wasm
  function type of forwarder and type checker functions.

- Two new code gen utilities added:
  - `Translator.indexArray`: generates code that indexes a Dart array
  - `Translator.getArrayLength`: generates code that gets length of a
    Dart array

- New `Reference` extensions added to get type checker function
  reference of members

- New library `named_parameters` implements two helper functions for
  dealing with named argument lists

- The library `dynamic_dispatch` is rewritten and now consists of two
  classes:

  - `Forwarders`: maintains mapping from call kind (get, set,
    invocation) and member name to forwarder functions.

  - `Forwarder`: a single forwarder, implements code generation for
    forwarder functions.

- `CodeGenerator` gets 3 new members:

  - `_callForwader` generates call to a forwarder

  - `generateSetterTypeCheckerMethod` generates code for a type checker
    of a setter function.

  - `generateInvocationTypeCheckerMethod` generates code for a type
    checker of a method.

    (TODO: This should be renamed to `generateMethodTypeCheckerMethod`
    for consistency)

Fixes dart-lang#50367

Change-Id: I2b9d84237c8517bd217166d8acb67e025f0498fb

Author: osa1

pkg/dart2wasm/lib/code_generator.dart

@@ -177,51 +177,6 @@ class SelectorInfo {
     return m.addFunctionType(
         [inputs[0], ...typeParameters, ...inputs.sublist(1)], outputs);
   }
-
-  /// Whether the selector can be applied in a [DynamicGet], [DynamicSet], or
-  /// [DynamicInvocation]. This only checks the argument counts and names, not
-  /// their types.
-  bool canApply(Expression dynamicExpression) {
-    if (dynamicExpression is DynamicGet || dynamicExpression is DynamicSet) {
-      // Dynamic get or set can always apply.
-      return true;
-    } else if (dynamicExpression is DynamicInvocation) {
-      Procedure member = paramInfo.member as Procedure;
-      Arguments arguments = dynamicExpression.arguments;
-      FunctionNode function = member.function;
-      if (arguments.types.isNotEmpty &&
-          arguments.types.length != function.typeParameters.length) {
-        return false;
-      }
-
-      if (arguments.positional.length < function.requiredParameterCount ||
-          arguments.positional.length > function.positionalParameters.length) {
-        return false;
-      }
-
-      Set<String> namedParameters = {};
-      Set<String> requiredNamedParameters = {};
-      for (VariableDeclaration v in function.namedParameters) {
-        if (v.isRequired) {
-          requiredNamedParameters.add(v.name!);
-        } else {
-          namedParameters.add(v.name!);
-        }
-      }
-
-      int requiredFound = 0;
-      for (NamedExpression namedArgument in arguments.named) {
-        bool found = requiredNamedParameters.contains(namedArgument.name);
-        if (found) {
-          requiredFound++;
-        } else if (!namedParameters.contains(namedArgument.name)) {
-          return false;
-        }
-      }
-      return requiredFound == requiredNamedParameters.length;
-    }
-    throw '"canApply" should only be used for procedures';
-  }
 }
 
 /// Builds the dispatch table for member calls.
@@ -313,18 +268,16 @@ class DispatchTable {
     return selector;
   }
 
-  /// Returns a possibly null list of [SelectorInfo]s for a given dynamic
-  /// call.
-  Iterable<SelectorInfo>? selectorsForDynamicNode(Expression node) {
-    if (node is DynamicGet) {
-      return _dynamicGets[node.name.text];
-    } else if (node is DynamicSet) {
-      return _dynamicSets[node.name.text];
-    } else if (node is DynamicInvocation) {
-      return _dynamicMethods[node.name.text];
-    } else {
-      throw 'Dynamic invocation of $node not supported';
-    }
+  Iterable<SelectorInfo>? selectorsForDynamicGet(String memberName) {
+    return _dynamicGets[memberName];
+  }
+
+  Iterable<SelectorInfo>? selectorsForDynamicSet(String memberName) {
+    return _dynamicSets[memberName];
+  }
+
+  Iterable<SelectorInfo>? selectorsForDynamicInvocation(String memberName) {
+    return _dynamicMethods[memberName];
   }
 
   void build() {