[dart2wasm] Add type parameter defaults to runtime function types

New passing tests:

- language/function/call_generic_test
- language/generic/function_bounds_test/01
- language/generic/function_bounds_test/03

Fixes #50992

Change-Id: I4f5e94a939661f6afb4dd78d74c5f7b0ef129cc4
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/283022
Reviewed-by: Aske Simon Christensen <[email protected]>
Commit-Queue: Ömer Ağacan <[email protected]>

Author: osa1

pkg/dart2wasm/lib/class_info.dart

@@ -34,7 +34,7 @@ class FieldIndex {
   static const instantiationContextTypeArgumentsBase = 1;
   static const typeIsDeclaredNullable = 2;
   static const interfaceTypeTypeArguments = 4;
-  static const functionTypeNamedParameters = 8;
+  static const functionTypeNamedParameters = 9;
   static const recordTypeNames = 3;
   static const recordTypeFieldTypes = 4;
   static const typedListBaseLength = 2;

pkg/dart2wasm/lib/constants.dart

@@ -717,6 +717,8 @@ class ConstantCreator extends ConstantVisitor<ConstantInfo?> {
     int typeParameterOffset = types.computeFunctionTypeParameterOffset(type);
     ListConstant typeParameterBoundsConstant = constants
         .makeTypeList(type.typeParameters.map((p) => p.bound).toList());
+    ListConstant typeParameterDefaultsConstant = constants
+        .makeTypeList(type.typeParameters.map((p) => p.defaultType).toList());
     TypeLiteralConstant returnTypeConstant =
         TypeLiteralConstant(type.returnType);
     ListConstant positionalParametersConstant =
@@ -726,6 +728,7 @@ class ConstantCreator extends ConstantVisitor<ConstantInfo?> {
     ListConstant namedParametersConstant =
         constants.makeNamedParametersList(type);
     ensureConstant(typeParameterBoundsConstant);
+    ensureConstant(typeParameterDefaultsConstant);
     ensureConstant(returnTypeConstant);
     ensureConstant(positionalParametersConstant);
     ensureConstant(requiredParameterCountConstant);
@@ -737,6 +740,8 @@ class ConstantCreator extends ConstantVisitor<ConstantInfo?> {
       b.i64_const(typeParameterOffset);
       constants.instantiateConstant(
           function, b, typeParameterBoundsConstant, types.typeListExpectedType);
+      constants.instantiateConstant(function, b, typeParameterDefaultsConstant,
+          types.typeListExpectedType);
       constants.instantiateConstant(
           function, b, returnTypeConstant, types.nonNullableTypeType);
       constants.instantiateConstant(function, b, positionalParametersConstant,

pkg/dart2wasm/lib/types.dart

@@ -385,8 +385,18 @@ class Types {
     w.Instructions b = codeGen.b;
     b.i32_const(encodedNullability(type));
     b.i64_const(typeParameterOffset);
+
+    // List<_Type> typeParameterBounds
     _makeTypeList(codeGen, type.typeParameters.map((p) => p.bound).toList());
+
+    // List<_Type> typeParameterDefaults
+    _makeTypeList(
+        codeGen, type.typeParameters.map((p) => p.defaultType).toList());
+
+    // _Type returnType
     makeType(codeGen, type.returnType);
+
+    // List<_Type> positionalParameters
     if (type.positionalParameters.every(_isTypeConstant)) {
       translator.constants.instantiateConstant(
           codeGen.function,
@@ -396,7 +406,11 @@ class Types {
     } else {
       _makeTypeList(codeGen, type.positionalParameters);
     }
+
+    // int requiredParameterCount
     b.i64_const(type.requiredParameterCount);
+
+    // List<_NamedParameter> namedParameters
     if (type.namedParameters.every((n) => _isTypeConstant(n.type))) {
       translator.constants.instantiateConstant(
           codeGen.function,

sdk/lib/_internal/wasm/lib/type.dart

@@ -316,6 +316,7 @@ class _FunctionType extends _Type {
   // representations that don't have this overhead in the common case.
   final int typeParameterOffset;
   final List<_Type> typeParameterBounds;
+  final List<_Type> typeParameterDefaults;
   final _Type returnType;
   final List<_Type> positionalParameters;
   final int requiredParameterCount;
@@ -325,6 +326,7 @@ class _FunctionType extends _Type {
   const _FunctionType(
       this.typeParameterOffset,
       this.typeParameterBounds,
+      this.typeParameterDefaults,
       this.returnType,
       this.positionalParameters,
       this.requiredParameterCount,
@@ -335,6 +337,7 @@ class _FunctionType extends _Type {
   _Type get _asNonNullable => _FunctionType(
       typeParameterOffset,
       typeParameterBounds,
+      typeParameterDefaults,
       returnType,
       positionalParameters,
       requiredParameterCount,
@@ -345,6 +348,7 @@ class _FunctionType extends _Type {
   _Type get _asNullable => _FunctionType(
       typeParameterOffset,
       typeParameterBounds,
+      typeParameterDefaults,
       returnType,
       positionalParameters,
       requiredParameterCount,
@@ -682,6 +686,12 @@ class _TypeUniverse {
                   .map((type) =>
                       substituteTypeArgument(type, substitutions, rootFunction))
                   .toList(),
+          isRoot
+              ? const []
+              : functionType.typeParameterDefaults
+                  .map((type) =>
+                      substituteTypeArgument(type, substitutions, rootFunction))
+                  .toList(),
           substituteTypeArgument(
               functionType.returnType, substitutions, rootFunction),
           functionType.positionalParameters
@@ -1032,10 +1042,9 @@ bool _checkClosureShape(_FunctionType functionType, List<_Type> typeArguments,
     List<Object?> positionalArguments, List<dynamic> namedArguments) {
   // Check type args, add default types to the type list if its empty
   if (typeArguments.isEmpty) {
-    // TODO(50992): Default values of type parameters are not available in
-    // runtime
-    typeArguments.addAll(functionType.typeParameterBounds);
-  } else if (typeArguments.length != functionType.typeParameterBounds.length) {
+    typeArguments.addAll(functionType.typeParameterDefaults);
+  } else if (typeArguments.length !=
+      functionType.typeParameterDefaults.length) {
     return false;
   }