feat: wasm text format and import support (vercel/turborepo#5636)

crates/turbopack-ecmascript/src/chunk/item.rs

@@ -24,7 +24,7 @@ use crate::{
 };
 
 #[turbo_tasks::value(shared)]
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct EcmascriptChunkItemContent {
  pub inner_code: Rope,
  pub source_map: Option<Vc<ParseResultSourceMap>>,

crates/turbopack-ecmascript/src/references/esm/mod.rs

@@ -11,7 +11,7 @@ pub use self::{
  base::EsmAssetReference,
  binding::EsmBinding,
  dynamic::EsmAsyncAssetReference,
- export::EsmExports,
+ export::{EsmExport, EsmExports},
  meta::{ImportMetaBinding, ImportMetaRef},
  module_item::EsmModuleItem,
  url::UrlAssetReference,

crates/turbopack-tests/tests/execution/turbopack/wasm/complex/input/README.md

@@ -0,0 +1,2 @@
+Adapted from webpack
+https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/examples/wasm-complex/README.md

crates/turbopack-tests/tests/execution/turbopack/wasm/complex/input/index.js

@@ -0,0 +1,20 @@
+describe("complex wasm", () => {
+ it("should be possible to use imported memory", async () => {
+ // magic.js is an async module, so we import it inside this function to make sure the entrypoint isn't async.
+ const { get, set } = await import("./magic.js");
+
+ set(42);
+ expect(get()).toEqual(42);
+ set(123);
+ expect(get()).toEqual(123);
+ });
+
+ it("should be possible to use imported functions", async () => {
+ // magic.js is an async module, so we import it inside this function to make sure the entrypoint isn't async.
+ const { getNumber } = await import("./magic.js");
+
+ // random numbers
+ expect(getNumber()).toBeGreaterThanOrEqual(0);
+ expect(getNumber()).toBeGreaterThanOrEqual(0);
+ });
+})

crates/turbopack-tests/tests/execution/turbopack/wasm/complex/input/magic-number.js

@@ -0,0 +1,7 @@
+export function getNumber() {
+ return 42;
+}
+
+export function getRandomNumber() {
+ return Math.floor(Math.random() * 256);
+}

crates/turbopack-tests/tests/execution/turbopack/wasm/complex/input/magic.js

@@ -0,0 +1,2 @@
+// reexporting
+export * from "./magic.wat";

crates/turbopack-tests/tests/execution/turbopack/wasm/complex/input/magic.wat

@@ -0,0 +1,15 @@
+(module
+ (type $t0 (func (result i32)))
+ (type $t1 (func (param i32)))
+ (import "./memory.js" "memory" (memory 1))
+ (import "./magic-number.js" "getRandomNumber" (func $getRandomNumber (type $t0)))
+ (func $get (export "get") (type $t0) (result i32)
+ (i32.load
+ (i32.const 0)))
+ (func $set (export "set") (type $t1) (param $p i32)
+ (i32.store
+ (i32.const 0)
+ (get_local $p)))
+ (func $getNumber (export "getNumber") (type $t0) (result i32)
+ (call $getRandomNumber))
+)

crates/turbopack-tests/tests/execution/turbopack/wasm/complex/input/memory.js

@@ -0,0 +1,7 @@
+async function getMemoryFromParentInWorker() {
+ await new Promise(r => setTimeout(r, 200));
+ // fake
+ return new WebAssembly.Memory({ initial: 1 });
+}
+
+export const memory = await getMemoryFromParentInWorker();

crates/turbopack-tests/tests/execution/turbopack/wasm/simple/input/index.js

@@ -1,5 +1,5 @@
 it("should handle wasm imports", async () => {
- // math.js is an async module, so we import it in here
+ // magic.js is an async module, so we import it inside this function to make sure the entrypoint isn't async.
  const {
  add,
  factorial,

crates/turbopack-wasm/Cargo.toml

@@ -12,15 +12,15 @@ bench = false
 [dependencies]
 anyhow = { workspace = true }
 indexmap = { workspace = true }
-
+indoc = { workspace = true }
+serde = { workspace = true }
 turbo-tasks = { workspace = true }
 turbo-tasks-fs = { workspace = true }
 turbo-tasks-hash = { workspace = true }
 turbopack-core = { workspace = true }
-turbopack-css = { workspace = true }
 turbopack-ecmascript = { workspace = true }
-
-serde = { workspace = true }
+wasmparser = "0.110.0"
+wat = "1.0.69"
 
 [build-dependencies]
 turbo-tasks-build = { workspace = true }

crates/turbopack-wasm/src/analysis.rs

@@ -0,0 +1,77 @@
+use std::collections::BTreeMap;
+
+use anyhow::Result;
+use turbo_tasks::Vc;
+use turbo_tasks_fs::FileContent;
+use turbopack_core::asset::Asset;
+use wasmparser::{Chunk, Parser, Payload};
+
+use crate::source::WebAssemblySource;
+
+/// Imports and exports of a WebAssembly file.
+#[turbo_tasks::value]
+#[derive(Default)]
+pub(crate) struct WebAssemblyAnalysis {
+ pub imports: BTreeMap<String, Vec<String>>,
+ pub exports: Vec<String>,
+}
+
+/// Analyse a WebAssembly file.
+///
+/// Extracts imports and exports.
+#[turbo_tasks::function]
+pub(crate) async fn analyze(source: Vc<WebAssemblySource>) -> Result<Vc<WebAssemblyAnalysis>> {
+ let content = source.content().file_content().await?;
+
+ let mut analysis = WebAssemblyAnalysis::default();
+
+ let FileContent::Content(file) = &*content else {
+ return Ok(analysis.cell());
+ };
+
+ let mut bytes = &*file.content().to_bytes()?;
+
+ let mut parser = Parser::new(0);
+ loop {
+ let payload = match parser.parse(bytes, true)? {
+ Chunk::Parsed { consumed, payload } => {
+ bytes = &bytes[consumed..];
+ payload
+ }
+ // this state isn't possible with `eof = true`
+ Chunk::NeedMoreData(_) => unreachable!(),
+ };
+
+ match payload {
+ Payload::ImportSection(s) => {
+ for import in s {
+ let import = import?;
+
+ analysis
+ .imports
+ .entry(import.module.to_string())
+ .or_default()
+ .push(import.name.to_string());
+ }
+ }
+ Payload::ExportSection(s) => {
+ for export in s {
+ let export = export?;
+
+ analysis.exports.push(export.name.to_string());
+ }
+ }
+
+ // skip over code sections
+ Payload::CodeSectionStart { size, .. } => {
+ parser.skip_section();
+ bytes = &bytes[size as usize..];
+ }
+
+ Payload::End(_) => break,
+ _ => {}
+ }
+ }
+
+ Ok(analysis.cell())
+}