wasm/jsapi/jspi/js-promise-integration.any.js

// META: global=window,dedicatedworker,jsshell
// META: script=/wasm/jsapi/wasm-module-builder.js

// Test for invalid wrappers
test(() => {
  assert_throws_js(TypeError, () => WebAssembly.promising({}),
      "Argument 0 must be a function");
  assert_throws_js(TypeError, () => WebAssembly.promising(() => {}),
      "Argument 0 must be a WebAssembly exported function");
  assert_throws_js(TypeError, () => WebAssembly.Suspending(() => {}),
      "WebAssembly.Suspending must be invoked with 'new'");
  assert_throws_js(TypeError, () => new WebAssembly.Suspending({}),
      "Argument 0 must be a function");

  function asmModule() {
      "use asm";

      function x(v) {
          v = v | 0;
      }
      return x;
  }
  assert_throws_js(TypeError, () => WebAssembly.promising(asmModule()),
      "Argument 0 must be a WebAssembly exported function");
},"Valid use of API");

test(() => {
  let builder = new WasmModuleBuilder();
  builder.addGlobal(kWasmI32, true).exportAs('g');
  builder.addFunction("test", kSig_i_v)
      .addBody([
          kExprI32Const, 42,
          kExprGlobalSet, 0,
          kExprI32Const, 0
      ]).exportFunc();
  let instance = builder.instantiate();
  let wrapper = WebAssembly.promising(instance.exports.test);
  wrapper();
  assert_equals(42, instance.exports.g.value);
},"Promising function always entered");

promise_test(async () => {
  let builder = new WasmModuleBuilder();
  let import_index = builder.addImport('m', 'import', kSig_i_v);
  builder.addFunction("test", kSig_i_i)
      .addBody([
          kExprCallFunction, import_index, // suspend
      ]).exportFunc();
  let js_import = () => 42;
  let instance = builder.instantiate({
      m: {
          import: js_import
      }
  });
  let wrapped_export = WebAssembly.promising(instance.exports.test);
  let export_promise = wrapped_export();
  assert_true(export_promise instanceof Promise);
  assert_equals(await export_promise, 42);
}, "Always get a Promise");

promise_test(async () => {
  let builder = new WasmModuleBuilder();
  let import_index = builder.addImport('m', 'import', kSig_i_i);
  builder.addFunction("test", kSig_i_i)
      .addBody([
          kExprLocalGet, 0,
          kExprCallFunction, import_index, // suspend
      ]).exportFunc();
  let js_import = new WebAssembly.Suspending(() => Promise.resolve(42));
  let instance = builder.instantiate({
      m: {
          import: js_import
      }
  });
  let wrapped_export = WebAssembly.promising(instance.exports.test);
  let export_promise = wrapped_export();
  assert_true(export_promise instanceof Promise);
  assert_equals(await export_promise, 42);
}, "Suspend once");

promise_test(async () => {
  let builder = new WasmModuleBuilder();
  builder.addGlobal(kWasmI32, true).exportAs('g');
  let import_index = builder.addImport('m', 'import', kSig_i_v);
  // void test() {
  //   for (i = 0; i < 5; ++i) {
  //     g = g + await import();
  //   }
  // }
  builder.addFunction("test", kSig_v_i)
      .addLocals({
          i32_count: 1
      })
      .addBody([
          kExprI32Const, 5,
          kExprLocalSet, 1,
          kExprLoop, kWasmStmt,
          kExprCallFunction, import_index, // suspend
          kExprGlobalGet, 0,
          kExprI32Add,
          kExprGlobalSet, 0,
          kExprLocalGet, 1,
          kExprI32Const, 1,
          kExprI32Sub,
          kExprLocalTee, 1,
          kExprBrIf, 0,
          kExprEnd,
      ]).exportFunc();
  let i = 0;

  function js_import() {
      return Promise.resolve(++i);
  };
  let wasm_js_import = new WebAssembly.Suspending(js_import);
  let instance = builder.instantiate({
      m: {
          import: wasm_js_import
      }
  });
  let wrapped_export = WebAssembly.promising(instance.exports.test);
  let export_promise = wrapped_export();
  assert_equals(instance.exports.g.value, 0);
  assert_true(export_promise instanceof Promise);
  await export_promise;
  assert_equals(instance.exports.g.value, 15);
}, "Suspend/resume in a loop");

promise_test(async () => {
  let builder = new WasmModuleBuilder();
  let import_index = builder.addImport('m', 'import', kSig_i_v);
  builder.addFunction("test", kSig_i_v)
      .addBody([
          kExprCallFunction, import_index, // suspend
      ]).exportFunc();
  let js_import = new WebAssembly.Suspending(() => Promise.resolve(42));
  let instance = builder.instantiate({
      m: {
          import: js_import
      }
  });
  let wrapped_export = WebAssembly.promising(instance.exports.test);
  assert_equals(await wrapped_export(), 42);

  // Also try with a JS function with a mismatching arity.
  js_import = new WebAssembly.Suspending((unused) => Promise.resolve(42));
  instance = builder.instantiate({
      m: {
          import: js_import
      }
  });
  wrapped_export = WebAssembly.promising(instance.exports.test);
  assert_equals(await wrapped_export(), 42);

  // Also try with a proxy.
  js_import = new WebAssembly.Suspending(new Proxy(() => Promise.resolve(42), {}));
  instance = builder.instantiate({
      m: {
          import: js_import
      }
  });
  wrapped_export = WebAssembly.promising(instance.exports.test);
  assert_equals(await wrapped_export(), 42);
},"Suspending with mismatched args and via Proxy");

function recordAbeforeB() {
  let AbeforeB = [];
  let setA = () => {
      AbeforeB.push("A")
  }
  let setB = () => {
      AbeforeB.push("B")
  }
  let isAbeforeB = () =>
      AbeforeB[0] == "A" && AbeforeB[1] == "B";

  let isBbeforeA = () =>
    AbeforeB[0] == "B" && AbeforeB[1] == "A";

  return {
      setA: setA,
      setB: setB,
      isAbeforeB: isAbeforeB,
      isBbeforeA: isBbeforeA,
  }
}

promise_test(async () => {
  let builder = new WasmModuleBuilder();
  let AbeforeB = recordAbeforeB();
  let import42_index = builder.addImport('m', 'import42', kSig_i_i);
  let importSetA_index = builder.addImport('m', 'setA', kSig_v_v);
  builder.addFunction("test", kSig_i_i)
      .addBody([
          kExprLocalGet, 0,
          kExprCallFunction, import42_index, // suspend?
          kExprCallFunction, importSetA_index
      ]).exportFunc();
  let import42 = new WebAssembly.Suspending(() => Promise.resolve(42));
  let instance = builder.instantiate({
      m: {
          import42: import42,
          setA: AbeforeB.setA
      }
  });

  let wrapped_export = WebAssembly.promising(instance.exports.test);

  let exported_promise = wrapped_export();

  AbeforeB.setB();

  assert_equals(await exported_promise, 42);

  assert_true(AbeforeB.isBbeforeA());
}, "Make sure we actually suspend");

promise_test(async () => {
  let builder = new WasmModuleBuilder();
  let AbeforeB = recordAbeforeB();
  let import42_index = builder.addImport('m', 'import42', kSig_i_i);
  let importSetA_index = builder.addImport('m', 'setA', kSig_v_v);
  builder.addFunction("test", kSig_i_i)
      .addBody([
          kExprLocalGet, 0,
          kExprCallFunction, import42_index, // suspend?
          kExprCallFunction, importSetA_index
      ]).exportFunc();
  let import42 = new WebAssembly.Suspending(() => 42);
  let instance = builder.instantiate({
      m: {
          import42: import42,
          setA: AbeforeB.setA
      }
  });

  let wrapped_export = WebAssembly.promising(instance.exports.test);

  let exported_promise = wrapped_export();
  AbeforeB.setB();

  assert_equals(await exported_promise, 42);
  assert_true(AbeforeB.isBbeforeA());
}, "Do suspend even if the import's return value is not a Promise by wrapping it with Promise.resolve");

promise_test(async (t) => {
  let tag = new WebAssembly.Tag({
      parameters: ['i32']
  });
  let builder = new WasmModuleBuilder();
  let import_index = builder.addImport('m', 'import', kSig_i_i);
  let tag_index = builder.addImportedTag('m', 'tag', kSig_v_i);
  builder.addFunction("test", kSig_i_i)
      .addBody([
          kExprTry, kWasmI32,
          kExprLocalGet, 0,
          kExprCallFunction, import_index,
          kExprCatch, tag_index,
          kExprEnd
      ]).exportFunc();

  function js_import(unused) {
      return Promise.reject(new WebAssembly.Exception(tag, [42]));
  };
  let wasm_js_import = new WebAssembly.Suspending(js_import);

  let instance = builder.instantiate({
      m: {
          import: wasm_js_import,
          tag: tag
      }
  });
  let wrapped_export = WebAssembly.promising(instance.exports.test);
  let export_promise = wrapped_export();
  assert_true(export_promise instanceof Promise);
  assert_equals(await export_promise, 42);
}, "Catch rejected promise");

async function TestSandwich(suspend) {
  // Set up a 'sandwich' scenario. The call chain looks like:
  // top (wasm) -> outer (js) -> bottom (wasm) -> inner (js)
  // If 'suspend' is true, the inner JS function returns a Promise, which
  // suspends the bottom wasm function, which returns a Promise, which suspends
  // the top wasm function, which returns a Promise. The inner Promise
  // resolves first, which resumes the bottom continuation. Then the outer
  // promise resolves which resumes the top continuation.
  // If 'suspend' is false, the bottom JS function returns a regular value and
  // no computation is suspended.
  let builder = new WasmModuleBuilder();
  let inner_index = builder.addImport('m', 'inner', kSig_i_i);
  let outer_index = builder.addImport('m', 'outer', kSig_i_i);
  builder.addFunction("top", kSig_i_i)
      .addBody([
          kExprLocalGet, 0,
          kExprCallFunction, outer_index
      ]).exportFunc();
  builder.addFunction("bottom", kSig_i_i)
      .addBody([
          kExprLocalGet, 0,
          kExprCallFunction, inner_index
      ]).exportFunc();

  let inner = new WebAssembly.Suspending(() => suspend ? Promise.resolve(42) : 43);

  let export_inner;
  let outer = new WebAssembly.Suspending(() => export_inner());

  let instance = builder.instantiate({
      m: {
          inner,
          outer
      }
  });
  export_inner = WebAssembly.promising(instance.exports.bottom);
  let export_top = WebAssembly.promising(instance.exports.top);
  let result = export_top();
  assert_true(result instanceof Promise);
  if (suspend)
      assert_equals(await result, 42);
  else
      assert_equals(await result, 43);
}

promise_test(async () => {
  TestSandwich(true);
}, "Test sandwich with suspension");

promise_test(async () => {
  TestSandwich(false);
}, "Test sandwich with no suspension");

test(() => {
  // Check that a promising function with no return is allowed.
  let builder = new WasmModuleBuilder();
  builder.addFunction("export", kSig_v_v).addBody([]).exportFunc();
  let instance = builder.instantiate();
  let export_wrapper = WebAssembly.promising(instance.exports.export);
  assert_true(export_wrapper instanceof Function);
},"Promising with no return");

promise_test(async () => {
  let builder1 = new WasmModuleBuilder();
  let import_index = builder1.addImport('m', 'import', kSig_i_v);
  builder1.addFunction("f", kSig_i_v)
      .addBody([
          kExprCallFunction, import_index, // suspend
          kExprI32Const, 1,
          kExprI32Add,
      ]).exportFunc();
  let js_import = new WebAssembly.Suspending(() => Promise.resolve(1));
  let instance1 = builder1.instantiate({
      m: {
          import: js_import
      }
  });
  let builder2 = new WasmModuleBuilder();
  import_index = builder2.addImport('m', 'import', kSig_i_v);
  builder2.addFunction("main", kSig_i_v)
      .addBody([
          kExprCallFunction, import_index,
          kExprI32Const, 1,
          kExprI32Add,
      ]).exportFunc();
  let instance2 = builder2.instantiate({
      m: {
          import: instance1.exports.f
      }
  });
  let wrapped_export = WebAssembly.promising(instance2.exports.main);
  assert_equals(await wrapped_export(), 3);
},"Suspend two modules");