[dart2wasm] Generate additional mjs module with JS support values.

This updates the dynamic module compile to emit an extra mjs file containing JS-defined functions and values (i.e. Strings). The runtime then loads this JS module along with the wasm module and links the two.

Change-Id: Iedddf378822f3abd957f0ca9016a9f7883854973
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/422341
Reviewed-by: Ömer Ağacan <[email protected]>
Commit-Queue: Nate Biggs <[email protected]>

Author: natebiggs

pkg/_js_interop_checks/lib/src/js_interop.dart

@@ -255,10 +255,10 @@ List<String> stringAnnotationValues(Expression node) {
   return values;
 }
 
-/// Returns the [Library] within [component] matching the specified
+/// Returns the [Library] within [libraries] matching the specified
 /// [interopUri] or [null].
-Library? _findJsInteropLibrary(Component component, Uri interopUri) {
-  for (Library lib in component.libraries) {
+Library? _findJsInteropLibrary(List<Library> libraries, Uri interopUri) {
+  for (Library lib in libraries) {
     for (LibraryDependency dependency in lib.dependencies) {
       Library targetLibrary = dependency.targetLibrary;
       if (targetLibrary.importUri == interopUri) {
@@ -276,19 +276,17 @@ Library? _findJsInteropLibrary(Component component, Uri interopUri) {
 /// `calculateTransitiveImportsOfDartFfiIfUsed` in
 /// pkg/vm/lib/transformations/ffi/common.dart.
 Set<Library> calculateTransitiveImportsOfJsInteropIfUsed(
-  Component component,
+  List<Library> libraries,
   Uri interopUri,
 ) {
   // Check for the presence of [jsInteropLibrary] as a dependency of any of the
   // libraries in [component]. We use this to bypass the expensive
   // [calculateTransitiveDependenciesOf] call for cases where js interop is
   // not used, otherwise we could just use the index of the library instead.
-  Library? jsInteropLibrary = _findJsInteropLibrary(component, interopUri);
+  Library? jsInteropLibrary = _findJsInteropLibrary(libraries, interopUri);
   if (jsInteropLibrary == null) return const <Library>{};
 
-  kernel_graph.LibraryGraph graph = kernel_graph.LibraryGraph(
-    component.libraries,
-  );
+  kernel_graph.LibraryGraph graph = kernel_graph.LibraryGraph(libraries);
   Set<Library> result = kernel_graph.calculateTransitiveDependenciesOf(graph, {
     jsInteropLibrary,
   });

pkg/dart2wasm/bin/run_wasm.js

@@ -404,21 +404,22 @@ const main = async () => {
     importObject.ffi = ffiInstance.exports;
   }
 
+  // Instantiate the Dart module, importing from the global scope.
+  const wasmFilename = args[wasmArg];
+  const wasmDirectory = wasmFilename.slice(0, wasmFilename.lastIndexOf('/'));
+
   globalThis.loadData = async (relativeToWasmFileUri) => {
-    var path = wasmFilename.slice(0, wasmFilename.lastIndexOf('/'));
-    return await readBytes(`${path}/${relativeToWasmFileUri}`);
+    return await readBytes(`${wasmDirectory}/${relativeToWasmFileUri}`);
   };
 
-  // Instantiate the Dart module, importing from the global scope.
-  const wasmFilename = args[wasmArg];
   const compiledApp = await dart2wasm.compile(readBytes(wasmFilename));
   const appInstance = await compiledApp.instantiate(importObject, {
     loadDeferredWasm: async (moduleName) => {
       let filename = wasmFilename.replace('.wasm', `_${moduleName}.wasm`);
       return readBytes(filename);
     },
-    loadDynamicModule: async (uri) => {
-      return readBytes(uri);
+    loadDynamicModule: async (wasmUri, mjsUri) => {
+      return [await readBytes(wasmUri), await import(`${wasmDirectory}/${mjsUri}`)];
     }
   });
 

pkg/dart2wasm/lib/compile.dart

@@ -54,7 +54,7 @@ sealed class CompilationResult {}
 
 class CompilationSuccess extends CompilationResult {
   final Map<String, ({Uint8List moduleBytes, String? sourceMap})> wasmModules;
-  final String? jsRuntime;
+  final String jsRuntime;
   final String supportJs;
 
   CompilationSuccess(this.wasmModules, this.jsRuntime, this.supportJs);
@@ -234,16 +234,16 @@ Future<CompilationResult> compileToModule(
   }
 
   final librariesToTransform = isDynamicModule
-      ? component.getMainModuleLibraries(coreTypes)
+      ? component.getDynamicModuleLibraries(coreTypes)
       : component.libraries;
   ConstantEvaluator constantEvaluator = ConstantEvaluator(
       options, target, component, coreTypes, classHierarchy, libraryIndex);
   unreachable_code_elimination.transformLibraries(target, librariesToTransform,
       constantEvaluator, options.translatorOptions.enableAsserts);
 
-  js.RuntimeFinalizer? jsRuntimeFinalizer = isDynamicModule
-      ? null
-      : js.createRuntimeFinalizer(component, coreTypes, classHierarchy);
+  js.RuntimeFinalizer? jsRuntimeFinalizer = js.RuntimeFinalizer(
+      js.performJSInteropTransformations(
+          librariesToTransform, coreTypes, classHierarchy));
 
   final Map<RecordShape, Class> recordClasses = generateRecordClasses(
       component, coreTypes, isDynamicMainModule || isDynamicModule);
@@ -328,14 +328,17 @@ Future<CompilationResult> compileToModule(
         (moduleBytes: wasmModuleSerialized, sourceMap: sourceMap);
   });
 
-  final jsRuntime = jsRuntimeFinalizer?.generate(
-      translator.functions.translatedProcedures,
-      translator.internalizedStringsForJSRuntime,
-      translator.options.requireJsStringBuiltin,
-      translator.options.enableDeferredLoading ||
-          translator.options.enableMultiModuleStressTestMode ||
-          translator.dynamicModuleSupportEnabled,
-      mode);
+  final jsRuntime = translator.isDynamicModule
+      ? jsRuntimeFinalizer.generateDynamicModule(
+          translator.functions.translatedProcedures,
+          translator.internalizedStringsForJSRuntime)
+      : jsRuntimeFinalizer.generate(
+          translator.functions.translatedProcedures,
+          translator.internalizedStringsForJSRuntime,
+          translator.options.requireJsStringBuiltin,
+          translator.options.enableDeferredLoading ||
+              translator.options.enableMultiModuleStressTestMode ||
+              translator.dynamicModuleSupportEnabled);
 
   final supportJs = _generateSupportJs(options.translatorOptions);
   if (isDynamicMainModule) {

pkg/dart2wasm/lib/dynamic_modules.dart

@@ -40,8 +40,8 @@ extension DynamicModuleComponent on Component {
       Expando<Procedure>();
 
   Procedure? get dynamicModuleEntryPoint => _dynamicModuleEntryPoint[this];
-  List<Library> getMainModuleLibraries(CoreTypes coreTypes) =>
-      [...libraries.where((l) => l.isFromMainModule(coreTypes))];
+  List<Library> getDynamicModuleLibraries(CoreTypes coreTypes) =>
+      [...libraries.where((l) => !l.isFromMainModule(coreTypes))];
 }
 
 extension DynamicModuleLibrary on Library {

pkg/dart2wasm/lib/generate_wasm.dart

@@ -115,9 +115,7 @@ Future<int> generateWasm(WasmCompilerOptions options,
 
   final jsFile = path.setExtension(options.outputFile, '.mjs');
   final jsRuntime = result.jsRuntime;
-  if (jsRuntime != null) {
-    await File(jsFile).writeAsString(jsRuntime);
-  }
+  await File(jsFile).writeAsString(jsRuntime);
 
   final supportJsFile = path.setExtension(options.outputFile, '.support.js');
   await File(supportJsFile).writeAsString(result.supportJs);

pkg/dart2wasm/lib/js/runtime_blob.dart

@@ -51,6 +51,13 @@ class CompiledApp {
   //   wasm file produced by the dart2wasm compiler and returns the bytes to
   //   load the module. These bytes can be in either a format supported by
   //   `WebAssembly.compile` or `WebAssembly.compileStreaming`.
+  // `loadDynamicModule` is a JS function that takes two string names matching,
+  //   in order, a wasm file produced by the dart2wasm compiler during dynamic
+  //   module compilation and a corresponding js file produced by the same
+  //   compilation. It should return a JS Array containing 2 elements. The first
+  //   should be the bytes for the wasm module in a format supported by
+  //   `WebAssembly.compile` or `WebAssembly.compileStreaming`. The second
+  //   should be the result of using the JS 'import' API on the js file path.
   async instantiate(additionalImports, {loadDeferredWasm, loadDynamicModule} = {}) {
     let dartInstance;
 
@@ -170,18 +177,12 @@ const jsStringPolyfill = {
 ''';
 
 final moduleLoadingHelperTemplate = Template(r'''
-const loadModuleFromBytes = async (bytes) => {
-        const module = await WebAssembly.compile(bytes, this.builtins);
-        return await WebAssembly.instantiate(module, {
-          ...baseImports,
-          ...additionalImports,
-          <<JS_POLYFILL_IMPORT>>
-          "module0": dartInstance.exports,
-        });
-    }
-
-    const loadModule = async (loader, loaderArgument) => {
-        const source = await Promise.resolve(loader(loaderArgument));
+    const moduleLoadingHelper = {
+      "loadModule": async (moduleName) => {
+        if (!loadDeferredWasm) {
+          throw "No implementation of loadDeferredWasm provided.";
+        }
+        const source = await Promise.resolve(loadDeferredWasm(moduleName));
         const module = await ((source instanceof Response)
             ? WebAssembly.compileStreaming(source, this.builtins)
             : WebAssembly.compile(source, this.builtins));
@@ -191,29 +192,37 @@ const loadModuleFromBytes = async (bytes) => {
           <<JS_POLYFILL_IMPORT>>
           "module0": dartInstance.exports,
         });
-    }
-
-    const moduleLoadingHelper = {
-      "loadModule": async (moduleName) => {
-        if (!loadDeferredWasm) {
-          throw "No implementation of loadDeferredWasm provided.";
-        }
-        return await loadModule(loadDeferredWasm, moduleName);
       },
-      "loadDynamicModuleFromUri": async (uri) => {
+      "loadDynamicModuleFromUri": async (wasmUri, jsUri) => {
         if (!loadDynamicModule) {
           throw "No implementation of loadDynamicModule provided.";
         }
-        const loadedModule = await loadModule(loadDynamicModule, uri);
-        return loadedModule.exports.$invokeEntryPoint;
-      },
-      "loadDynamicModuleFromBytes": async (bytes) => {
-        const loadedModule = await loadModuleFromBytes(loadDynamicModule, uri);
+        const [source, jsModule] = await loadDynamicModule(wasmUri, jsUri);
+        const module = await ((source instanceof Response)
+            ? WebAssembly.compileStreaming(source, this.builtins)
+            : WebAssembly.compile(source, this.builtins));
+        const loadedModule = await WebAssembly.instantiate(module, {
+          "module0": dartInstance.exports,
+          ...jsModule.imports(finalizeWrapper),
+        });
         return loadedModule.exports.$invokeEntryPoint;
       },
     };
 ''');
 
+final dynamicModuleJsImportTemplate = Template(r'''
+export function imports(finalizeWrapper) {
+  const dart2wasm = {
+    <<JS_METHODS>>
+  };
+
+  return {
+    dart2wasm: dart2wasm,
+    <<IMPORTED_JS_STRINGS_IN_MJS>>
+  };
+}
+''');
+
 class Template {
   static final _templateVariableRegExp = RegExp(r'<<(?<varname>[A-Z_]+)>>');
   final List<_TemplatePart> _parts = [];

pkg/dart2wasm/lib/js/runtime_generator.dart

@@ -12,16 +12,12 @@ import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 
-import '../target.dart' as wasm_target;
 import 'interop_transformer.dart';
 import 'method_collector.dart';
 import 'runtime_blob.dart';
 
-JSMethods _performJSInteropTransformations(
-    Component component,
-    CoreTypes coreTypes,
-    ClassHierarchy classHierarchy,
-    Set<Library> interopDependentLibraries) {
+JSMethods _performJSInteropTransformations(CoreTypes coreTypes,
+    ClassHierarchy classHierarchy, Set<Library> interopDependentLibraries) {
   // Transform kernel and generate JS methods.
   final transformer = InteropTransformer(coreTypes, classHierarchy);
   for (final library in interopDependentLibraries) {
@@ -50,18 +46,13 @@ JSMethods _performJSInteropTransformations(
 }
 
 class RuntimeFinalizer {
+  static String escape(String s) => json.encode(s);
+
   final Map<Procedure, ({String importName, String jsCode})> allJSMethods;
 
   RuntimeFinalizer(this.allJSMethods);
 
-  String generate(
-      Iterable<Procedure> translatedProcedures,
-      List<String> constantStrings,
-      bool requireJsBuiltin,
-      bool supportsAdditionalModuleLoading,
-      wasm_target.Mode mode) {
-    String escape(String s) => json.encode(s);
-
+  String generateJsMethods(Iterable<Procedure> translatedProcedures) {
     Set<Procedure> usedProcedures = {};
     final usedJSMethods = <({String importName, String jsCode})>[];
     for (Procedure p in translatedProcedures) {
@@ -91,19 +82,31 @@ class RuntimeFinalizer {
       }
     }
 
-    final builtins = [
-      'builtins: [\'js-string\']',
-      if (requireJsBuiltin) 'importedStringConstants: \'S\'',
-    ];
+    return jsMethods.toString();
+  }
 
-    String internalizedStrings = '';
-    if (constantStrings.isNotEmpty) {
-      internalizedStrings = '''
+  String _generateInternalizedStrings(List<String> constantStrings) {
+    if (constantStrings.isEmpty) return '';
+    return '''
       s: [
         ${constantStrings.map(escape).join(',\n')}
       ],
 ''';
-    }
+  }
+
+  String generate(
+      Iterable<Procedure> translatedProcedures,
+      List<String> constantStrings,
+      bool requireJsBuiltin,
+      bool supportsAdditionalModuleLoading) {
+    final jsMethods = generateJsMethods(translatedProcedures);
+
+    final builtins = [
+      'builtins: [\'js-string\']',
+      if (requireJsBuiltin) 'importedStringConstants: \'S\'',
+    ];
+
+    String internalizedStrings = _generateInternalizedStrings(constantStrings);
 
     final jsStringBuiltinPolyfillImportVars = {
       'JS_POLYFILL_IMPORT':
@@ -125,29 +128,40 @@ class RuntimeFinalizer {
       ...jsStringBuiltinPolyfillImportVars,
       ...moduleLoadingImportVars,
       'BUILTINS_MAP_BODY': builtins.join(', '),
-      'JS_METHODS': jsMethods.toString(),
+      'JS_METHODS': jsMethods,
       'IMPORTED_JS_STRINGS_IN_MJS': internalizedStrings,
       'JS_STRING_POLYFILL_METHODS': requireJsBuiltin ? '' : jsPolyFillMethods,
       'DEFERRED_LIBRARY_HELPER_METHODS': moduleLoadingHelperMethods,
     });
   }
+
+  String generateDynamicModule(
+      Iterable<Procedure> translatedProcedures, List<String> constantStrings) {
+    final jsMethods = generateJsMethods(translatedProcedures);
+
+    return dynamicModuleJsImportTemplate.instantiate({
+      'JS_METHODS': jsMethods,
+      'IMPORTED_JS_STRINGS_IN_MJS':
+          _generateInternalizedStrings(constantStrings),
+    });
+  }
 }
 
-RuntimeFinalizer createRuntimeFinalizer(
-    Component component, CoreTypes coreTypes, ClassHierarchy classHierarchy) {
+JSMethods performJSInteropTransformations(List<Library> libraries,
+    CoreTypes coreTypes, ClassHierarchy classHierarchy) {
   Set<Library> transitiveImportingJSInterop = {
     ...calculateTransitiveImportsOfJsInteropIfUsed(
-        component, Uri.parse("package:js/js.dart")),
+        libraries, Uri.parse("package:js/js.dart")),
     ...calculateTransitiveImportsOfJsInteropIfUsed(
-        component, Uri.parse("dart:_js_annotations")),
+        libraries, Uri.parse("dart:_js_annotations")),
     ...calculateTransitiveImportsOfJsInteropIfUsed(
-        component, Uri.parse("dart:_js_helper")),
+        libraries, Uri.parse("dart:_js_helper")),
     ...calculateTransitiveImportsOfJsInteropIfUsed(
-        component, Uri.parse("dart:js_interop")),
+        libraries, Uri.parse("dart:js_interop")),
   };
-  final jsInteropMethods = _performJSInteropTransformations(
-      component, coreTypes, classHierarchy, transitiveImportingJSInterop);
-  return RuntimeFinalizer(jsInteropMethods);
+
+  return _performJSInteropTransformations(
+      coreTypes, classHierarchy, transitiveImportingJSInterop);
 }
 
 // Removes indentation common among all lines of [block] (except for first one)

pkg/dart2wasm/lib/target.dart

@@ -281,15 +281,15 @@ class WasmTarget extends Target {
 
     Set<Library> transitiveImportingJSInterop = {
       ...jsInteropHelper.calculateTransitiveImportsOfJsInteropIfUsed(
-          component, Uri.parse("package:js/js.dart")),
+          component.libraries, Uri.parse("package:js/js.dart")),
       ...jsInteropHelper.calculateTransitiveImportsOfJsInteropIfUsed(
-          component, Uri.parse("dart:_js_annotations")),
+          component.libraries, Uri.parse("dart:_js_annotations")),
       ...jsInteropHelper.calculateTransitiveImportsOfJsInteropIfUsed(
-          component, Uri.parse("dart:js_interop")),
+          component.libraries, Uri.parse("dart:js_interop")),
       ...jsInteropHelper.calculateTransitiveImportsOfJsInteropIfUsed(
-          component, Uri.parse("dart:convert")),
+          component.libraries, Uri.parse("dart:convert")),
       ...jsInteropHelper.calculateTransitiveImportsOfJsInteropIfUsed(
-          component, Uri.parse("dart:_string")),
+          component.libraries, Uri.parse("dart:_string")),
     };
     if (transitiveImportingJSInterop.isEmpty) {
       logger?.call("Skipped JS interop transformations");