[dart2wasm] Support different default values within the same selector

Default parameter values are implemented in dart2wasm via caller-side
substitution. When the same parameter has different default values
across different implementations within the same selector, a
special sentinel value is passed by the caller, and the callee
checks for this value and substitutes the actual default value.

Change-Id: I8235145f93c2aee7e9ef603456380253b836fcef
Cq-Include-Trybots: luci.dart.try:dart2wasm-linux-x64-d8-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/259040
Commit-Queue: Aske Simon Christensen <[email protected]>
Reviewed-by: Joshua Litt <[email protected]>

Author: askeksa

pkg/dart2wasm/lib/code_generator.dart

@@ -324,15 +324,37 @@ class CodeGenerator extends ExpressionVisitor1<w.ValueType, w.ValueType>
     ParameterInfo paramInfo = translator.paramInfoFor(reference);
     int parameterOffset = _initializeThis(member);
     int implicitParams = parameterOffset + paramInfo.typeParamCount;
+
+    void setupParamLocal(
+        VariableDeclaration variable, int index, Constant? defaultValue) {
+      w.Local local = paramLocals[implicitParams + index];
+      locals[variable] = local;
+      if (defaultValue == ParameterInfo.defaultValueSentinel) {
+        // The default value for this parameter differs between implementations
+        // within the same selector. This means that callers will pass the
+        // default value sentinel to indicate that the parameter is not given.
+        // The callee must check for the sentinel value and substitute the
+        // actual default value.
+        b.local_get(local);
+        translator.constants.instantiateConstant(
+            function, b, ParameterInfo.defaultValueSentinel, local.type);
+        b.ref_eq();
+        b.if_();
+        wrap(variable.initializer!, local.type);
+        b.local_set(local);
+        b.end();
+      }
+    }
+
     List<VariableDeclaration> positional =
         member.function!.positionalParameters;
     for (int i = 0; i < positional.length; i++) {
-      locals[positional[i]] = paramLocals[implicitParams + i];
+      setupParamLocal(positional[i], i, paramInfo.positional[i]);
     }
     List<VariableDeclaration> named = member.function!.namedParameters;
     for (var param in named) {
-      locals[param] =
-          paramLocals[implicitParams + paramInfo.nameIndex[param.name]!];
+      setupParamLocal(
+          param, paramInfo.nameIndex[param.name]!, paramInfo.named[param.name]);
     }
     List<TypeParameter> typeParameters = member is Constructor
         ? member.enclosingClass.typeParameters

pkg/dart2wasm/lib/constants.dart

@@ -7,6 +7,7 @@ import 'dart:typed_data';
 
 import 'package:dart2wasm/class_info.dart';
 import 'package:dart2wasm/closures.dart';
+import 'package:dart2wasm/param_info.dart';
 import 'package:dart2wasm/translator.dart';
 import 'package:dart2wasm/types.dart';
 
@@ -335,6 +336,19 @@ class ConstantInstantiator extends ConstantVisitor<w.ValueType> {
     }
   }
 
+  @override
+  w.ValueType visitUnevaluatedConstant(UnevaluatedConstant constant) {
+    if (constant == ParameterInfo.defaultValueSentinel) {
+      // Instantiate a sentinel value specific to the parameter type.
+      w.ValueType sentinelType = expectedType.withNullability(false);
+      assert(sentinelType is w.RefType,
+          "Default value sentinel for unboxed parameter");
+      translator.globals.instantiateDummyValue(b, sentinelType);
+      return sentinelType;
+    }
+    return super.visitUnevaluatedConstant(constant);
+  }
+
   @override
   w.ValueType visitNullConstant(NullConstant node) {
     w.ValueType? expectedType = this.expectedType;

pkg/dart2wasm/lib/dispatch_table.dart

@@ -60,6 +60,7 @@ class SelectorInfo {
         List.generate(1 + paramInfo.paramCount, (_) => {});
     List<Set<ClassInfo>> outputSets = List.generate(returnCount, (_) => {});
     List<bool> inputNullable = List.filled(1 + paramInfo.paramCount, false);
+    List<bool> ensureBoxed = List.filled(1 + paramInfo.paramCount, false);
     List<bool> outputNullable = List.filled(returnCount, false);
     targets.forEach((id, target) {
       ClassInfo receiver = translator.classes[id];
@@ -99,18 +100,23 @@ class SelectorInfo {
       }
       assert(returns.length <= outputSets.length);
       inputSets[0].add(receiver);
+      ensureBoxed[0] = true;
       for (int i = 0; i < positional.length; i++) {
         DartType type = positional[i];
         inputSets[1 + i]
             .add(translator.classInfo[translator.classForType(type)]!);
         inputNullable[1 + i] |= type.isPotentiallyNullable;
+        ensureBoxed[1 + i] |=
+            paramInfo.positional[i] == ParameterInfo.defaultValueSentinel;
       }
       for (String name in named.keys) {
         int i = nameIndex[name]!;
         DartType type = named[name]!;
         inputSets[1 + i]
             .add(translator.classInfo[translator.classForType(type)]!);
         inputNullable[1 + i] |= type.isPotentiallyNullable;
+        ensureBoxed[1 + i] |=
+            paramInfo.named[name] == ParameterInfo.defaultValueSentinel;
       }
       for (int i = 0; i < returnCount; i++) {
         if (i < returns.length) {
@@ -128,8 +134,8 @@ class SelectorInfo {
     List<w.ValueType> inputs = List.generate(
         inputSets.length,
         (i) => translator.typeForInfo(
-                upperBound(inputSets[i]), inputNullable[i], ensureBoxed: i == 0)
-            as w.ValueType);
+            upperBound(inputSets[i]), inputNullable[i],
+            ensureBoxed: ensureBoxed[i]) as w.ValueType);
     if (name == '==') {
       // == can't be called with null
       inputs[1] = inputs[1].withNullability(false);

pkg/dart2wasm/lib/param_info.dart

@@ -20,6 +20,12 @@ class ParameterInfo {
     for (int i = 0; i < names.length; i++) names[i]: positional.length + i
   };
 
+  /// A special marker value to use for default parameter values to indicate
+  /// that different implementations within the same selector have different
+  /// default values.
+  static final Constant defaultValueSentinel =
+      UnevaluatedConstant(InvalidExpression("Default value sentinel"));
+
   int get paramCount => positional.length + named.length;
 
   static Constant? defaultValue(VariableDeclaration param) {
@@ -82,9 +88,8 @@ class ParameterInfo {
           positional[i] = other.positional[i];
         } else if (other.positional[i] != null) {
           if (positional[i] != other.positional[i]) {
-            print("Mismatching default value for parameter $i: "
-                "${member}: ${positional[i]} vs "
-                "${other.member}: ${other.positional[i]}");
+            // Default value differs between implementations.
+            positional[i] = defaultValueSentinel;
           }
         }
       }
@@ -96,9 +101,8 @@ class ParameterInfo {
         named[name] = otherValue;
       } else if (otherValue != null) {
         if (value != otherValue) {
-          print("Mismatching default value for parameter '$name': "
-              "${member}: ${value} vs "
-              "${other.member}: ${otherValue}");
+          // Default value differs between implementations.
+          named[name] = defaultValueSentinel;
         }
       }
     }