[dart2wasm] Compute instance method parameter types from Wasm types.

This improves the precision of the Wasm types for Dart function types
in instance method signatures.

It could in principle also improve the precision of the receiver
parameter from the LUB of the representation types to the LUB of the
actual structs for the classes implementing the member. However,
if at a call site the receiver parameter type is more precise than the
representation type of the receiver, the call site will need to cast
the receiver to the more precise type. This gives rise to more casts
in practice than the ones saved inside the methods by the more precise
receiver parameter type. For this reason, the receiver parameter type
is kept at the LUB of the representation types of the classes
implementing the member.

This change is also a stepping stone towards not having `ClassInfo`
for the special Wasm types.

CoreLibraryReviewExempt: Only affects Wasm-specific libraries.
Change-Id: I81ca5aa1107f1c04ed7729a758e983698492a106
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/288400
Reviewed-by: Joshua Litt <[email protected]>
Commit-Queue: Aske Simon Christensen <[email protected]>

Author: askeksa

pkg/dart2wasm/lib/class_info.dart

@@ -130,7 +130,7 @@ class ClassInfo {
   /// The class whose struct is used as the type for variables of this type.
   /// This is a type which is a superclass of all subtypes of this type.
   late final ClassInfo repr = upperBound(
-      implementedBy.map((c) => identical(c, this) ? this : c.repr).toList());
+      implementedBy.map((c) => identical(c, this) ? this : c.repr).toSet());
 
   /// All classes which implement this class. This is used to compute `repr`.
   final List<ClassInfo> implementedBy = [];
@@ -158,7 +158,7 @@ class ClassInfo {
   }
 }
 
-ClassInfo upperBound(Iterable<ClassInfo> classes) {
+ClassInfo upperBound(Set<ClassInfo> classes) {
   while (classes.length > 1) {
     Set<ClassInfo> newClasses = {};
     int minDepth = 999999999;

pkg/dart2wasm/lib/dispatch_table.dart

@@ -2,6 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'dart:math' show min;
+
 import 'package:dart2wasm/class_info.dart';
 import 'package:dart2wasm/param_info.dart';
 import 'package:dart2wasm/reference_extensions.dart';
@@ -83,18 +85,17 @@ class SelectorInfo {
   w.FunctionType _computeSignature() {
     var nameIndex = paramInfo.nameIndex;
     final int returnCount = isSetter ? 0 : 1;
-    List<Set<ClassInfo>> inputSets =
+    List<Set<w.ValueType>> inputSets =
         List.generate(1 + paramInfo.paramCount, (_) => {});
-    List<Set<ClassInfo>> outputSets = List.generate(returnCount, (_) => {});
-    List<bool> inputNullable = List.filled(1 + paramInfo.paramCount, false);
+    List<Set<w.ValueType>> outputSets = List.generate(returnCount, (_) => {});
     List<bool> ensureBoxed = List.filled(1 + paramInfo.paramCount, false);
-    List<bool> outputNullable = List.filled(returnCount, false);
     targets.forEach((classId, target) {
-      ClassInfo receiver = translator.classes[classId];
+      Member member = target.asMember;
+      DartType receiver =
+          InterfaceType(member.enclosingClass!, Nullability.nonNullable);
       List<DartType> positional;
       Map<String, DartType> named;
       List<DartType> returns;
-      Member member = target.asMember;
       if (member is Field) {
         if (target.isImplicitGetter) {
           positional = const [];
@@ -137,54 +138,79 @@ class SelectorInfo {
         }
       }
       assert(returns.length <= outputSets.length);
-      inputSets[0].add(receiver);
-      ensureBoxed[0] = true;
+      inputSets[0].add(translator.translateType(receiver));
+      ensureBoxed[0] = member.enclosingClass != translator.ffiPointerClass;
       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;
+        inputSets[1 + i].add(translator.translateType(type));
         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;
+        inputSets[1 + i].add(translator.translateType(type));
         ensureBoxed[1 + i] |=
             paramInfo.named[name] == ParameterInfo.defaultValueSentinel;
       }
       for (int i = 0; i < returnCount; i++) {
         if (i < returns.length) {
-          outputSets[i]
-              .add(translator.classInfo[translator.classForType(returns[i])]!);
-          outputNullable[i] |= returns[i].isPotentiallyNullable;
+          DartType type = returns[i];
+          outputSets[i].add(translator.translateType(type));
         } else {
-          outputNullable[i] = true;
+          outputSets[i].add(translator.topInfo.nullableType);
         }
       }
     });
 
     List<w.ValueType> typeParameters = List.filled(paramInfo.typeParamCount,
         translator.classInfo[translator.typeClass]!.nonNullableType);
-    List<w.ValueType> inputs = List.generate(
-        inputSets.length,
-        (i) => translator.typeForInfo(
-            upperBound(inputSets[i]), inputNullable[i],
-            ensureBoxed: ensureBoxed[i]) as w.ValueType);
+    List<w.ValueType> inputs = List.generate(inputSets.length,
+        (i) => _upperBound(inputSets[i], ensureBoxed: ensureBoxed[i]));
     if (name == '==') {
       // == can't be called with null
       inputs[1] = inputs[1].withNullability(false);
     }
-    List<w.ValueType> outputs = List.generate(
-        outputSets.length,
-        (i) => translator.typeForInfo(
-            upperBound(outputSets[i]), outputNullable[i]) as w.ValueType);
+    List<w.ValueType> outputs = List.generate(outputSets.length,
+        (i) => _upperBound(outputSets[i], ensureBoxed: false));
     return m.addFunctionType(
         [inputs[0], ...typeParameters, ...inputs.sublist(1)], outputs);
   }
+
+  w.ValueType _upperBound(Set<w.ValueType> types, {required bool ensureBoxed}) {
+    if (!ensureBoxed && types.length == 1 && types.single.isPrimitive) {
+      // Unboxed primitive.
+      return types.single;
+    }
+    final bool nullable = types.any((type) => type.nullable);
+    int minDepth = 999999999;
+    Set<w.DefType> heapTypes = types
+        .where((type) => type is! w.RefType || type.heapType is w.DefType)
+        .map((type) {
+      w.DefType def = type is w.RefType
+          ? type.heapType as w.DefType
+          : translator.classInfo[translator.boxedClasses[type]!]!.struct;
+      minDepth = min(minDepth, def.depth);
+      return def;
+    }).toSet();
+    if (heapTypes.isEmpty) {
+      // Only abstract heap types.
+      Set<w.HeapType> heapTypes =
+          types.map((type) => (type as w.RefType).heapType).toSet();
+      return w.RefType(heapTypes.single, nullable: nullable);
+    }
+    int targetDepth = minDepth;
+    while (heapTypes.length > 1) {
+      heapTypes = heapTypes.map((s) {
+        while (s.depth > targetDepth) {
+          s = s.superType!;
+        }
+        return s;
+      }).toSet();
+      targetDepth -= 1;
+    }
+    return w.RefType.def(heapTypes.single, nullable: nullable);
+  }
 }
 
 /// Builds the dispatch table for member calls.

pkg/dart2wasm/lib/transformers.dart

@@ -30,6 +30,7 @@ class _WasmTransformer extends Transformer {
   StaticTypeContext? _cachedTypeContext;
   final Library _coreLibrary;
   final InterfaceType _nonNullableTypeType;
+  final Class _wasmBaseClass;
   final List<_AsyncStarFrame> _asyncStarFrames = [];
   bool _enclosingIsAsyncStar = false;
   late final controllerNullableObjectType = InterfaceType(
@@ -52,6 +53,7 @@ class _WasmTransformer extends Transformer {
         _nonNullableTypeType = coreTypes.index
             .getClass('dart:core', '_Type')
             .getThisType(coreTypes, Nullability.nonNullable),
+        _wasmBaseClass = coreTypes.index.getClass('dart:wasm', '_WasmBase'),
         _coreLibrary = coreTypes.index.getLibrary('dart:core');
 
   @override
@@ -108,6 +110,7 @@ class _WasmTransformer extends Transformer {
     // `Type` object.
     if (!cls.isAbstract &&
         cls != coreTypes.objectClass &&
+        !env.hierarchy.isSubclassOf(cls, _wasmBaseClass) &&
         !canReuseSuperMethod(cls)) {
       Procedure getTypeArguments = Procedure(
           Name("_typeArguments", _coreLibrary),

pkg/dart2wasm/lib/translator.dart

@@ -462,43 +462,26 @@ class Translator with KernelNodes {
 
   bool isFfiCompound(Class cls) => _hasSuperclass(cls, ffiCompoundClass);
 
-  w.StorageType typeForInfo(ClassInfo info, bool nullable,
-      {bool ensureBoxed = false}) {
-    Class? cls = info.cls;
-    if (cls != null) {
-      w.StorageType? builtin = builtinTypes[cls];
-      if (builtin != null) {
-        if (!nullable && (!ensureBoxed || cls == ffiPointerClass)) {
-          return builtin;
-        }
-        if (isWasmType(cls)) {
-          if (builtin.isPrimitive) throw "Wasm numeric types can't be nullable";
-          return (builtin as w.RefType).withNullability(nullable);
-        }
-        if (cls == ffiPointerClass) throw "FFI types can't be nullable";
-        Class? boxedClass = boxedClasses[builtin];
-        if (boxedClass != null) {
-          info = classInfo[boxedClass]!;
-        }
-      } else if (isFfiCompound(cls)) {
-        if (nullable) throw "FFI types can't be nullable";
-        return w.NumType.i32;
-      } else if (cls == coreTypes.functionClass) {
+  w.StorageType translateStorageType(DartType type) {
+    bool nullable = type.isPotentiallyNullable;
+    if (type is InterfaceType) {
+      Class cls = type.classNode;
+
+      // Abstract `Function`?
+      if (cls == coreTypes.functionClass) {
         return w.RefType.def(closureLayouter.closureBaseStruct,
             nullable: nullable);
       }
-    }
-    return w.RefType.def(info.repr.struct, nullable: nullable);
-  }
 
-  w.StorageType translateStorageType(DartType type) {
-    if (type is InterfaceType) {
-      if (type.classNode.superclass == wasmArrayRefClass) {
+      // Wasm array?
+      if (cls.superclass == wasmArrayRefClass) {
         DartType elementType = type.typeArguments.single;
         return w.RefType.def(arrayTypeForDartType(elementType),
-            nullable: false);
+            nullable: nullable);
       }
-      if (type.classNode == wasmFunctionClass) {
+
+      // Wasm function?
+      if (cls == wasmFunctionClass) {
         DartType functionType = type.typeArguments.single;
         if (functionType is! FunctionType) {
           throw "The type argument of a WasmFunction must be a function type";
@@ -520,10 +503,31 @@ class Translator with KernelNodes {
           if (!voidReturn) translateType(functionType.returnType)
         ];
         w.FunctionType wasmType = m.addFunctionType(inputs, outputs);
-        return w.RefType.def(wasmType, nullable: type.isPotentiallyNullable);
+        return w.RefType.def(wasmType, nullable: nullable);
+      }
+
+      // FFI compound?
+      if (isFfiCompound(cls)) {
+        if (nullable) throw "FFI types can't be nullable";
+        return w.NumType.i32;
       }
-      return typeForInfo(
-          classInfo[type.classNode]!, type.isPotentiallyNullable);
+
+      // Other built-in type?
+      w.StorageType? builtin = builtinTypes[cls];
+      if (builtin != null) {
+        if (!nullable) {
+          return builtin;
+        }
+        if (isWasmType(cls)) {
+          if (builtin.isPrimitive) throw "Wasm numeric types can't be nullable";
+          return (builtin as w.RefType).withNullability(nullable);
+        }
+        if (cls == ffiPointerClass) throw "FFI types can't be nullable";
+        return classInfo[boxedClasses[builtin]!]!.nullableType;
+      }
+
+      // Regular class.
+      return classInfo[cls]!.repr.typeWithNullability(nullable);
     }
     if (type is DynamicType || type is VoidType) {
       return topInfo.nullableType;
@@ -532,15 +536,15 @@ class Translator with KernelNodes {
       return const w.RefType.none(nullable: true);
     }
     if (type is TypeParameterType) {
-      return translateStorageType(type.isPotentiallyNullable
+      return translateStorageType(nullable
           ? type.bound.withDeclaredNullability(type.nullability)
           : type.bound);
     }
     if (type is IntersectionType) {
       return translateStorageType(type.left);
     }
     if (type is FutureOrType) {
-      return topInfo.typeWithNullability(type.isPotentiallyNullable);
+      return topInfo.typeWithNullability(nullable);
     }
     if (type is FunctionType) {
       ClosureRepresentation? representation =
@@ -552,13 +556,13 @@ class Translator with KernelNodes {
           representation != null
               ? representation.closureStruct
               : classInfo[typeClass]!.struct,
-          nullable: type.isPotentiallyNullable);
+          nullable: nullable);
     }
     if (type is InlineType) {
       return translateStorageType(type.instantiatedRepresentationType);
     }
     if (type is RecordType) {
-      return typeForInfo(getRecordClassInfo(type), type.isPotentiallyNullable);
+      return getRecordClassInfo(type).typeWithNullability(nullable);
     }
     throw "Unsupported type ${type.runtimeType}";
   }

sdk/lib/wasm/wasm_types.dart

@@ -41,7 +41,9 @@ class WasmAnyRef extends _WasmBase {
   ///
   /// Will throw if the reference is not a Dart object.
   external Object toObject();
+}
 
+extension ExternalizeNonNullable on WasmAnyRef {
   WasmExternRef externalize() => _externalizeNonNullable(this);
 }
 
@@ -55,7 +57,9 @@ class WasmExternRef extends _WasmBase {
   // To avoid conflating the null externref with Dart's null, we provide a
   // special getter for the null externref.
   external static WasmExternRef? get nullRef;
+}
 
+extension InternalizeNonNullable on WasmExternRef {
   WasmAnyRef internalize() => _internalizeNonNullable(this);
 }