[dart2wasm] Initial commit for the Dart-to-WasmGC compiler.

This is work in progress. Several language features are still
unimplemented or only partially implemented.

Instructions for running the compiler and its output can be found in
pkg/dart2wasm/dart2wasm.md. These procedures are preliminary and
expected to change.

The best version of d8 to use for this version of dart2wasm is 10.0.40,
as explained here: https://dart-review.googlesource.com/c/sdk/+/232097

This commit also adds a dart2wasm-hostasserts-linux-x64-d8 testing
configuration to run the compiler over the test suite.

The history of the prototype that this is based on can be seen here:

https://github.com/askeksa-google/sdk/tree/wasm_prototype

Issue: #32894

Change-Id: I910b6ff239ef9c5f66863e4ca97b39b8202cce85
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/175728
Reviewed-by: Joshua Litt <[email protected]>
Commit-Queue: Aske Simon Christensen <[email protected]>

Author: askeksa

.dart_tool/package_config.json

@@ -228,6 +228,12 @@
       "packageUri": "lib/",
       "languageVersion": "2.12"
     },
+    {
+      "name": "dart2wasm",
+      "rootUri": "../pkg/dart2wasm",
+      "packageUri": "lib/",
+      "languageVersion": "2.12"
+    },
     {
       "name": "dart_internal",
       "rootUri": "../pkg/dart_internal",
@@ -780,6 +786,12 @@
       "packageUri": "lib/",
       "languageVersion": "2.12"
     },
+    {
+      "name": "wasm_builder",
+      "rootUri": "../pkg/wasm_builder",
+      "packageUri": "lib/",
+      "languageVersion": "2.12"
+    },
     {
       "name": "watcher",
       "rootUri": "../third_party/pkg/watcher",

.packages

@@ -33,6 +33,7 @@ dart2js_info:pkg/dart2js_info/lib
 dart2js_runtime_metrics:pkg/dart2js_runtime_metrics/lib
 dart2js_tools:pkg/dart2js_tools/lib
 dart2native:pkg/dart2native/lib
+dart2wasm:pkg/dart2wasm/lib
 dart_internal:pkg/dart_internal/lib
 dart_style:third_party/pkg_tested/dart_style/lib
 dartdev:pkg/dartdev/lib
@@ -117,6 +118,7 @@ vector_math:third_party/pkg/vector_math/lib
 vm:pkg/vm/lib
 vm_service:pkg/vm_service/lib
 vm_snapshot_analysis:pkg/vm_snapshot_analysis/lib
+wasm_builder:pkg/wasm_builder/lib
 watcher:third_party/pkg/watcher/lib
 webdriver:third_party/pkg/webdriver/lib
 webkit_inspection_protocol:third_party/pkg/webkit_inspection_protocol/lib

pkg/dart2wasm/bin/dart2wasm.dart

@@ -0,0 +1,99 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// 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:io';
+import 'dart:typed_data';
+
+import 'package:front_end/src/api_unstable/vm.dart'
+    show printDiagnosticMessage, resolveInputUri;
+
+import 'package:dart2wasm/compile.dart';
+import 'package:dart2wasm/translator.dart';
+
+final Map<String, void Function(TranslatorOptions, bool)> boolOptionMap = {
+  "export-all": (o, value) => o.exportAll = value,
+  "inlining": (o, value) => o.inlining = value,
+  "lazy-constants": (o, value) => o.lazyConstants = value,
+  "local-nullability": (o, value) => o.localNullability = value,
+  "name-section": (o, value) => o.nameSection = value,
+  "nominal-types": (o, value) => o.nominalTypes = value,
+  "parameter-nullability": (o, value) => o.parameterNullability = value,
+  "polymorphic-specialization": (o, value) =>
+      o.polymorphicSpecialization = value,
+  "print-kernel": (o, value) => o.printKernel = value,
+  "print-wasm": (o, value) => o.printWasm = value,
+  "runtime-types": (o, value) => o.runtimeTypes = value,
+  "string-data-segments": (o, value) => o.stringDataSegments = value,
+};
+final Map<String, void Function(TranslatorOptions, int)> intOptionMap = {
+  "watch": (o, value) => (o.watchPoints ??= []).add(value),
+};
+
+Never usage(String message) {
+  print("Usage: dart2wasm [<options>] <infile.dart> <outfile.wasm>");
+  print("");
+  print("Options:");
+  print("  --dart-sdk=<path>");
+  print("");
+  for (String option in boolOptionMap.keys) {
+    print("  --[no-]$option");
+  }
+  print("");
+  for (String option in intOptionMap.keys) {
+    print("  --$option <value>");
+  }
+  print("");
+
+  throw message;
+}
+
+Future<int> main(List<String> args) async {
+  Uri sdkPath = Platform.script.resolve("../../../sdk");
+  TranslatorOptions options = TranslatorOptions();
+  List<String> nonOptions = [];
+  void Function(TranslatorOptions, int)? intOptionFun = null;
+  for (String arg in args) {
+    if (intOptionFun != null) {
+      intOptionFun(options, int.parse(arg));
+      intOptionFun = null;
+    } else if (arg.startsWith("--dart-sdk=")) {
+      String path = arg.substring("--dart-sdk=".length);
+      sdkPath = Uri.file(Directory(path).absolute.path);
+    } else if (arg.startsWith("--no-")) {
+      var optionFun = boolOptionMap[arg.substring(5)];
+      if (optionFun == null) usage("Unknown option $arg");
+      optionFun(options, false);
+    } else if (arg.startsWith("--")) {
+      var optionFun = boolOptionMap[arg.substring(2)];
+      if (optionFun != null) {
+        optionFun(options, true);
+      } else {
+        intOptionFun = intOptionMap[arg.substring(2)];
+        if (intOptionFun == null) usage("Unknown option $arg");
+      }
+    } else {
+      nonOptions.add(arg);
+    }
+  }
+  if (intOptionFun != null) {
+    usage("Missing argument to ${args.last}");
+  }
+
+  if (nonOptions.length != 2) usage("Requires two file arguments");
+  String input = nonOptions[0];
+  String output = nonOptions[1];
+  Uri mainUri = resolveInputUri(input);
+
+  Uint8List? module = await compileToModule(mainUri, sdkPath, options,
+      (message) => printDiagnosticMessage(message, print));
+
+  if (module == null) {
+    exitCode = 1;
+    return exitCode;
+  }
+
+  await File(output).writeAsBytes(module);
+
+  return 0;
+}

pkg/dart2wasm/bin/run_wasm.js

@@ -0,0 +1,63 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// 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.
+//
+// Runner V8 script for testing dart2wasm, takes ".wasm" file as argument.
+// Run as follows:
+//
+// $> d8 --experimental-wasm-gc --wasm-gc-js-interop run_wasm.js -- <file_name>.wasm
+
+function stringFromDartString(string) {
+    var length = inst.exports.$stringLength(string);
+    var array = new Array(length);
+    for (var i = 0; i < length; i++) {
+        array[i] = inst.exports.$stringRead(string, i);
+    }
+    return String.fromCharCode(...array);
+}
+
+function stringToDartString(string) {
+    var length = string.length;
+    var range = 0;
+    for (var i = 0; i < length; i++) {
+        range |= string.codePointAt(i);
+    }
+    if (range < 256) {
+        var dartString = inst.exports.$stringAllocate1(length);
+        for (var i = 0; i < length; i++) {
+            inst.exports.$stringWrite1(dartString, i, string.codePointAt(i));
+        }
+        return dartString;
+    } else {
+        var dartString = inst.exports.$stringAllocate2(length);
+        for (var i = 0; i < length; i++) {
+            inst.exports.$stringWrite2(dartString, i, string.codePointAt(i));
+        }
+        return dartString;
+    }
+}
+
+// Imports for printing and event loop
+var dart2wasm = {
+    printToConsole: function(string) {
+        console.log(stringFromDartString(string))
+    },
+    scheduleCallback: function(milliseconds, closure) {
+        setTimeout(function() {
+            inst.exports.$call0(closure);
+        }, milliseconds);
+    }
+};
+
+// Create a Wasm module from the binary wasm file.
+var bytes = readbuffer(arguments[0]);
+var module = new WebAssembly.Module(bytes);
+
+// Instantiate the Wasm module, importing from the global scope.
+var importObject = (typeof window !== 'undefined')
+    ? window
+    : Realm.global(Realm.current());
+var inst = new WebAssembly.Instance(module, importObject);
+
+var result = inst.exports.main();
+if (result) console.log(result);

pkg/dart2wasm/dart2wasm.md

@@ -0,0 +1,65 @@
+## Running dart2wasm
+
+You don't need to build the Dart SDK to run dart2wasm, as long as you have a Dart SDK installed.
+
+To compile a Dart file to Wasm, run:
+
+`dart --enable-asserts pkg/dart2wasm/bin/dart2wasm.dart` *options* *infile*`.dart` *outfile*`.wasm`
+
+where *options* include:
+
+| Option                                  | Default | Description |
+| --------------------------------------- | ------- | ----------- |
+| `--dart-sdk=`*path*                     | relative to script | The location of the `sdk` directory inside the Dart SDK, containing the core library sources.
+| `--`[`no-`]`export-all`                 | no      | Export all functions; otherwise, just export `main`.
+| `--`[`no-`]`inlining`                   | no      | Inline small functions.
+| `--`[`no-`]`lazy-constants`             | no      | Instantiate constants lazily.
+| `--`[`no-`]`local-nullability`          | no      | Use non-nullable types for non-nullable locals and temporaries.
+| `--`[`no-`]`name-section`               | yes     | Emit Name Section with function names.
+| `--`[`no-`]`nominal-types`              | no      | Emit experimental nominal types.
+| `--`[`no-`]`parameter-nullability`      | yes     | Use non-nullable types for non-nullable parameters and return values.
+| `--`[`no-`]`polymorphic-specialization` | no      | Do virtual calls by switching on the class ID instead of using `call_indirect`.
+| `--`[`no-`]`print-kernel`               | no      | Print IR for each function before compiling it.
+| `--`[`no-`]`print-wasm`                 | no      | Print Wasm instructions of each compiled function.
+| `--`[`no-`]`runtime-types`              | yes     | Use RTTs for allocations and casts.
+| `--`[`no-`]`string-data-segments`       | no      | Use experimental array init from data segment for string constants.
+| `--watch` *offset*                      |         | Print stack trace leading to the byte at offset *offset* in the `.wasm` output file. Can be specified multiple times.
+
+The resulting `.wasm` file can be run with:
+
+`d8 --experimental-wasm-gc --wasm-gc-js-interop pkg/dart2wasm/bin/run_wasm.js -- `*outfile*`.wasm`
+
+## Imports and exports
+
+To import a function, declare it as a global, external function and mark it with a `wasm:import` pragma indicating the imported name (which must be two identifiers separated by a dot):
+```dart
+@pragma("wasm:import", "foo.bar")
+external void fooBar(Object object);
+```
+which will call `foo.bar` on the host side:
+```javascript
+var foo = {
+    bar: function(object) { /* implementation here */ }
+};
+```
+To export a function, mark it with a `wasm:export` pragma:
+```dart
+@pragma("wasm:export")
+void foo(double x) { /* implementation here */  }
+
+@pragma("wasm:export", "baz")
+void bar(double x) { /* implementation here */  }
+```
+With the Wasm module instance in `inst`, these can be called as:
+```javascript
+inst.exports.foo(1);
+inst.exports.baz(2);
+```
+
+### Types to use for interop
+
+In the signatures of imported and exported functions, use the following types:
+
+- For numbers, use `double`.
+- For Dart objects, use the corresponding Dart type. The fields of the underlying representation can be accessed on the JS side as `.$field0`, `.$field1` etc., but there is currently no defined way of finding the field index of a particular Dart field, so this mechanism is mainly useful for special objects with known layout.
+- For JS objects, use the `WasmAnyRef` type (or `WasmAnyRef?` as applicable) from the `dart:wasm` package. These can be passed around and stored as opaque values on the Dart side.