[dart2wasm] Take advantage of fast js-string builtins

Some wasm engines have started to optimize the `js-string` builtin
proposal (e.g. V8) and those that haven't yet are probaly going to
do soon.

So we can start taking advantage of it in dart2wasm.

=> We make use of them in the JS<->Dart string copy code.

=> This will also provide a better baseline when evaluating whether
   switching to JS stringes entirely makes sense.

A somewhat unrelated (but necessary for this CL) change is to tighten
the types we use in `@pragma('wasm:import')` and
`@pragma('wasm:export')` in some cases:

We should only use 'pure' wasm types (i.e. not wasm struct / function
types we define for dart classes & functions) and mostly non-composed
types in import/exports as the `--closed-world` optimizations from
binaryen rely on that (and error otherwise).

Overall this leads to significant improvements in Dart<->JS
string copies.

The `WasmDataTransfer.*{From,To}BrowserString` benchmarks
improve something between 50-100%.

Change-Id: I2048113c462ecb2047402c0616d2b3b1f45773f5
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/400641
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Slava Egorov <[email protected]>

Author: mkustermann

pkg/dart2wasm/lib/js/inline_expander.dart

@@ -88,7 +88,7 @@ class InlineExpander {
       String parameterString = 'x$j';
       DartType type = originalArgument.getStaticType(_staticTypeContext);
       dartPositionalParameters.add(VariableDeclaration(parameterString,
-          type: type, isSynthesized: true));
+          type: _toExternalType(type), isSynthesized: true));
       if (originalArgument is! VariableGet) {
         allArgumentsAreGet = false;
       }
@@ -121,4 +121,18 @@ class InlineExpander {
     _methodCollector.addMethod(dartProcedure, jsMethodName, codeTemplate);
     return result;
   }
+
+  // The `JS<foo>("...some js code ...", arg0, arg1)` expressions will produce
+  // wasm imports. We want to only use types in those wasm imports that binaryen
+  // allows under closed world assumptions (and not blindly use `arg<N>`s static
+  // type).
+  //
+  // For now we special case `WasmArray<>` which we turn into a generic `array`
+  // type (super type of all wasm arrays).
+  DartType _toExternalType(DartType type) {
+    if (type is InterfaceType && type.classNode == _util.wasmArrayClass) {
+      return InterfaceType(_util.wasmArrayRefClass, type.declaredNullability);
+    }
+    return type;
+  }
 }

pkg/dart2wasm/lib/js/runtime_blob.dart

@@ -129,6 +129,26 @@ const jsRuntimeBlobPart3 = r'''
       "fromCharCode": (i) => String.fromCharCode(i),
       "length": (s) => s.length,
       "substring": (s, a, b) => s.substring(a, b),
+      "fromCharCodeArray": (a, start, end) => {
+        if (end <= start) return '';
+
+        const read = dartInstance.exports.$wasmI16ArrayGet;
+        let result = '';
+        let index = start;
+        const chunkLength = Math.min(end - index, 500);
+        let array = new Array(chunkLength);
+        while (index < end) {
+          const newChunkLength = Math.min(end - index, 500);
+          for (let i = 0; i < newChunkLength; i++) {
+            array[i] = read(a, index++);
+          }
+          if (newChunkLength < chunkLength) {
+            array = array.slice(0, newChunkLength);
+          }
+          result += String.fromCharCode(...array);
+        }
+        return result;
+      },
     };
 
     const deferredLibraryHelper = {

pkg/dart2wasm/lib/js/util.dart

@@ -27,6 +27,8 @@ class CoreTypesUtil {
   final Procedure jsValueUnboxTarget;
   final Procedure numToIntTarget;
   final Class wasmExternRefClass;
+  final Class wasmArrayClass;
+  final Class wasmArrayRefClass;
   final Procedure wrapDartFunctionTarget;
 
   CoreTypesUtil(this.coreTypes, this._extensionIndex)
@@ -64,6 +66,9 @@ class CoreTypesUtil {
             .firstWhere((p) => p.name.text == 'unbox'),
         wasmExternRefClass =
             coreTypes.index.getClass('dart:_wasm', 'WasmExternRef'),
+        wasmArrayClass = coreTypes.index.getClass('dart:_wasm', 'WasmArray'),
+        wasmArrayRefClass =
+            coreTypes.index.getClass('dart:_wasm', 'WasmArrayRef'),
         wrapDartFunctionTarget = coreTypes.index
             .getTopLevelProcedure('dart:_js_helper', '_wrapDartFunction');
 

pkg/dart2wasm/lib/translator.dart

@@ -690,7 +690,7 @@ class Translator with KernelNodes {
   /// (`anyref`, `funcref` or `externref`).
   /// This function can be called before the class info is built.
   w.ValueType translateExternalType(DartType type) {
-    bool isPotentiallyNullable = type.isPotentiallyNullable;
+    final bool isPotentiallyNullable = type.isPotentiallyNullable;
     if (type is InterfaceType) {
       Class cls = type.classNode;
       if (cls == wasmFuncRefClass || cls == wasmFunctionClass) {
@@ -699,6 +699,16 @@ class Translator with KernelNodes {
       if (cls == wasmExternRefClass) {
         return w.RefType.extern(nullable: isPotentiallyNullable);
       }
+      if (cls == wasmArrayRefClass) {
+        return w.RefType.array(nullable: isPotentiallyNullable);
+      }
+      if (cls == wasmArrayClass) {
+        final elementType =
+            translateExternalStorageType(type.typeArguments.single);
+        return w.RefType.def(
+            wasmArrayType(elementType, '$elementType', mutable: true),
+            nullable: isPotentiallyNullable);
+      }
       if (!isPotentiallyNullable) {
         w.StorageType? builtin = builtinTypes[cls];
         if (builtin != null && builtin.isPrimitive) {
@@ -711,6 +721,22 @@ class Translator with KernelNodes {
     return w.RefType.any(nullable: true);
   }
 
+  w.StorageType translateExternalStorageType(DartType type) {
+    if (type is InterfaceType) {
+      final cls = type.classNode;
+      if (isWasmType(cls)) {
+        final isNullable = type.isPotentiallyNullable;
+        final w.StorageType? builtin = builtinTypes[cls];
+        if (builtin != null) {
+          if (!isNullable) return builtin;
+          if (builtin.isPrimitive) throw "Wasm numeric types can't be nullable";
+          return (builtin as w.RefType).withNullability(isNullable);
+        }
+      }
+    }
+    return translateExternalType(type) as w.RefType;
+  }
+
   /// Creates a global reference to [f] in [module]. [f] must also be located
   /// in [module].
   w.Global makeFunctionRef(w.ModuleBuilder module, w.BaseFunction f) {