casts.tentative.any.js

// META: global=window,dedicatedworker,jsshell

// META: script=/wasm/jsapi/wasm-module-builder.js

let exports = {};

setup(() => {

  const builder = new WasmModuleBuilder();

  const structIndex = builder.addStruct([makeField(kWasmI32, true)]);

  const arrayIndex = builder.addArray(kWasmI32, true);

  const structIndex2 = builder.addStruct([makeField(kWasmF32, true)]);

  const arrayIndex2 = builder.addArray(kWasmF32, true);

  const funcIndex = builder.addType({ params: [], results: [] });

  const funcIndex2 = builder.addType({ params: [], results: [kWasmI32] });

  const argFunctions = [

    { name: "any", code: kWasmAnyRef },

    { name: "eq", code: kWasmEqRef },

    { name: "struct", code: kWasmStructRef },

    { name: "array", code: kWasmArrayRef },

    { name: "i31", code: kWasmI31Ref },

    { name: "func", code: kWasmFuncRef },

    { name: "extern", code: kWasmExternRef },

    { name: "none", code: kWasmNullRef },

    { name: "nofunc", code: kWasmNullFuncRef },

    { name: "noextern", code: kWasmNullExternRef },

    { name: "concreteStruct", code: structIndex },

    { name: "concreteArray", code: arrayIndex },

    { name: "concreteFunc", code: funcIndex },

];

  for (const desc of argFunctions) {

    builder

      .addFunction(desc.name + "Arg", makeSig_v_x(wasmRefType(desc.code)))

      .addBody([])

      .exportFunc();

    builder

      .addFunction(desc.name + "NullableArg", makeSig_v_x(wasmRefNullType(desc.code)))

      .addBody([])

      .exportFunc();

  builder

    .addFunction("makeStruct", makeSig_r_v(wasmRefType(structIndex)))

    .addBody([...wasmI32Const(42),

              ...GCInstr(kExprStructNew), structIndex])

    .exportFunc();

  builder

    .addFunction("makeArray", makeSig_r_v(wasmRefType(arrayIndex)))

    .addBody([...wasmI32Const(5), ...wasmI32Const(42),

              ...GCInstr(kExprArrayNew), arrayIndex])

    .exportFunc();

  builder

    .addFunction("makeStruct2", makeSig_r_v(wasmRefType(structIndex2)))

    .addBody([...wasmF32Const(42),

              ...GCInstr(kExprStructNew), structIndex2])

    .exportFunc();

  builder

    .addFunction("makeArray2", makeSig_r_v(wasmRefType(arrayIndex2)))

    .addBody([...wasmF32Const(42), ...wasmI32Const(5),

              ...GCInstr(kExprArrayNew), arrayIndex2])

    .exportFunc();

  builder

    .addFunction("testFunc", funcIndex)

    .addBody([])

    .exportFunc();

  builder

    .addFunction("testFunc2", funcIndex2)

    .addBody([...wasmI32Const(42)])

    .exportFunc();

  const buffer = builder.toBuffer();

  const module = new WebAssembly.Module(buffer);

  const instance = new WebAssembly.Instance(module, {});

  exports = instance.exports;

});

test(() => {

  exports.anyArg(exports.makeStruct());

  exports.anyArg(exports.makeArray());

  exports.anyArg(42);

  exports.anyArg(42n);

  exports.anyArg("foo");

  exports.anyArg({});

  exports.anyArg(() => {});

  exports.anyArg(exports.testFunc);

  assert_throws_js(TypeError, () => exports.anyArg(null));

  exports.anyNullableArg(null);

  exports.anyNullableArg(exports.makeStruct());

  exports.anyNullableArg(exports.makeArray());

  exports.anyNullableArg(42);

  exports.anyNullableArg(42n);

  exports.anyNullableArg("foo");

  exports.anyNullableArg({});

  exports.anyNullableArg(() => {});

  exports.anyNullableArg(exports.testFunc);

}, "anyref casts");

test(() => {

  exports.eqArg(exports.makeStruct());

  exports.eqArg(exports.makeArray());

  exports.eqArg(42);

  assert_throws_js(TypeError, () => exports.eqArg(42n));

  assert_throws_js(TypeError, () => exports.eqArg("foo"));

  assert_throws_js(TypeError, () => exports.eqArg({}));

  assert_throws_js(TypeError, () => exports.eqArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.eqArg(() => {}));

  assert_throws_js(TypeError, () => exports.eqArg(null));

  exports.eqNullableArg(null);

  exports.eqNullableArg(exports.makeStruct());

  exports.eqNullableArg(exports.makeArray());

  exports.eqNullableArg(42);

  assert_throws_js(TypeError, () => exports.eqNullableArg(42n));

  assert_throws_js(TypeError, () => exports.eqNullableArg("foo"));

  assert_throws_js(TypeError, () => exports.eqNullableArg({}));

  assert_throws_js(TypeError, () => exports.eqNullableArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.eqNullableArg(() => {}));

}, "eqref casts");

test(() => {

  exports.structArg(exports.makeStruct());

  assert_throws_js(TypeError, () => exports.structArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.structArg(42));

  assert_throws_js(TypeError, () => exports.structArg(42n));

  assert_throws_js(TypeError, () => exports.structArg("foo"));

  assert_throws_js(TypeError, () => exports.structArg({}));

  assert_throws_js(TypeError, () => exports.structArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.structArg(() => {}));

  assert_throws_js(TypeError, () => exports.structArg(null));

  exports.structNullableArg(null);

  exports.structNullableArg(exports.makeStruct());

  assert_throws_js(TypeError, () => exports.structNullableArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.structNullableArg(42));

  assert_throws_js(TypeError, () => exports.structNullableArg(42n));

  assert_throws_js(TypeError, () => exports.structNullableArg("foo"));

  assert_throws_js(TypeError, () => exports.structNullableArg({}));

  assert_throws_js(TypeError, () => exports.structNullableArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.structNullableArg(() => {}));

}, "structref casts");

test(() => {

  exports.arrayArg(exports.makeArray());

  assert_throws_js(TypeError, () => exports.arrayArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.arrayArg(42));

  assert_throws_js(TypeError, () => exports.arrayArg(42n));

  assert_throws_js(TypeError, () => exports.arrayArg("foo"));

  assert_throws_js(TypeError, () => exports.arrayArg({}));

  assert_throws_js(TypeError, () => exports.arrayArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.arrayArg(() => {}));

  assert_throws_js(TypeError, () => exports.arrayArg(null));

  exports.arrayNullableArg(null);

  exports.arrayNullableArg(exports.makeArray());

  assert_throws_js(TypeError, () => exports.arrayNullableArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.arrayNullableArg(42));

  assert_throws_js(TypeError, () => exports.arrayNullableArg(42n));

  assert_throws_js(TypeError, () => exports.arrayNullableArg("foo"));

  assert_throws_js(TypeError, () => exports.arrayNullableArg({}));

  assert_throws_js(TypeError, () => exports.arrayNullableArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.arrayNullableArg(() => {}));

}, "arrayref casts");

test(() => {

  exports.i31Arg(42);

  assert_throws_js(TypeError, () => exports.i31Arg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.i31Arg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.i31Arg(42n));

  assert_throws_js(TypeError, () => exports.i31Arg("foo"));

  assert_throws_js(TypeError, () => exports.i31Arg({}));

  assert_throws_js(TypeError, () => exports.i31Arg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.i31Arg(() => {}));

  assert_throws_js(TypeError, () => exports.i31Arg(null));

  exports.i31NullableArg(null);

  exports.i31NullableArg(42);

  assert_throws_js(TypeError, () => exports.i31NullableArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.i31NullableArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.i31NullableArg(42n));

  assert_throws_js(TypeError, () => exports.i31NullableArg("foo"));

  assert_throws_js(TypeError, () => exports.i31NullableArg({}));

  assert_throws_js(TypeError, () => exports.i31NullableArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.i31NullableArg(() => {}));

}, "i31ref casts");

test(() => {

  exports.funcArg(exports.testFunc);

  assert_throws_js(TypeError, () => exports.funcArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.funcArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.funcArg(42));

  assert_throws_js(TypeError, () => exports.funcArg(42n));

  assert_throws_js(TypeError, () => exports.funcArg("foo"));

  assert_throws_js(TypeError, () => exports.funcArg({}));

  assert_throws_js(TypeError, () => exports.funcArg(() => {}));

  assert_throws_js(TypeError, () => exports.funcArg(null));

  exports.funcNullableArg(null);

  exports.funcNullableArg(exports.testFunc);

  assert_throws_js(TypeError, () => exports.funcNullableArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.funcNullableArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.funcNullableArg(42));

  assert_throws_js(TypeError, () => exports.funcNullableArg(42n));

  assert_throws_js(TypeError, () => exports.funcNullableArg("foo"));

  assert_throws_js(TypeError, () => exports.funcNullableArg({}));

  assert_throws_js(TypeError, () => exports.funcNullableArg(() => {}));

}, "funcref casts");

test(() => {

  exports.externArg(exports.makeArray());

  exports.externArg(exports.makeStruct());

  exports.externArg(42);

  exports.externArg(42n);

  exports.externArg("foo");

  exports.externArg({});

  exports.externArg(exports.testFunc);

  exports.externArg(() => {});

  assert_throws_js(TypeError, () => exports.externArg(null));

  exports.externNullableArg(null);

  exports.externNullableArg(exports.makeArray());

  exports.externNullableArg(exports.makeStruct());

  exports.externNullableArg(42);

  exports.externNullableArg(42n);

  exports.externNullableArg("foo");

  exports.externNullableArg({});

  exports.externNullableArg(exports.testFunc);

  exports.externNullableArg(() => {});

}, "externref casts");

test(() => {

  for (const nullfunc of [exports.noneArg, exports.nofuncArg, exports.noexternArg]) {

    assert_throws_js(TypeError, () => nullfunc(exports.makeStruct()));

    assert_throws_js(TypeError, () => nullfunc(exports.makeArray()));

    assert_throws_js(TypeError, () => nullfunc(42));

    assert_throws_js(TypeError, () => nullfunc(42n));

    assert_throws_js(TypeError, () => nullfunc("foo"));

    assert_throws_js(TypeError, () => nullfunc({}));

    assert_throws_js(TypeError, () => nullfunc(exports.testFunc));

    assert_throws_js(TypeError, () => nullfunc(() => {}));

    assert_throws_js(TypeError, () => nullfunc(null));

  for (const nullfunc of [exports.noneNullableArg, exports.nofuncNullableArg, exports.noexternNullableArg]) {

    nullfunc(null);

    assert_throws_js(TypeError, () => nullfunc(exports.makeStruct()));

    assert_throws_js(TypeError, () => nullfunc(exports.makeArray()));

    assert_throws_js(TypeError, () => nullfunc(42));

    assert_throws_js(TypeError, () => nullfunc(42n));

    assert_throws_js(TypeError, () => nullfunc("foo"));

    assert_throws_js(TypeError, () => nullfunc({}));

    assert_throws_js(TypeError, () => nullfunc(exports.testFunc));

    assert_throws_js(TypeError, () => nullfunc(() => {}));

}, "null casts");

test(() => {

  exports.concreteStructArg(exports.makeStruct());

  assert_throws_js(TypeError, () => exports.concreteStructArg(exports.makeStruct2()));

  assert_throws_js(TypeError, () => exports.concreteStructArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.concreteStructArg(42));

  assert_throws_js(TypeError, () => exports.concreteStructArg(42n));

  assert_throws_js(TypeError, () => exports.concreteStructArg("foo"));

  assert_throws_js(TypeError, () => exports.concreteStructArg({}));

  assert_throws_js(TypeError, () => exports.concreteStructArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.concreteStructArg(() => {}));

  assert_throws_js(TypeError, () => exports.concreteStructArg(null));

  exports.concreteStructNullableArg(null);

  exports.concreteStructNullableArg(exports.makeStruct());

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(exports.makeStruct2()));

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(42));

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(42n));

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg("foo"));

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg({}));

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.concreteStructNullableArg(() => {}));

}, "concrete struct casts");

test(() => {

  exports.concreteArrayArg(exports.makeArray());

  assert_throws_js(TypeError, () => exports.concreteArrayArg(exports.makeArray2()));

  assert_throws_js(TypeError, () => exports.concreteArrayArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.concreteArrayArg(42));

  assert_throws_js(TypeError, () => exports.concreteArrayArg(42n));

  assert_throws_js(TypeError, () => exports.concreteArrayArg("foo"));

  assert_throws_js(TypeError, () => exports.concreteArrayArg({}));

  assert_throws_js(TypeError, () => exports.concreteArrayArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.concreteArrayArg(() => {}));

  assert_throws_js(TypeError, () => exports.concreteArrayArg(null));

  exports.concreteArrayNullableArg(null);

  exports.concreteArrayNullableArg(exports.makeArray());

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(exports.makeArray2()));

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(42));

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(42n));

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg("foo"));

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg({}));

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(exports.testFunc));

  assert_throws_js(TypeError, () => exports.concreteArrayNullableArg(() => {}));

}, "concrete array casts");

test(() => {

  exports.concreteFuncArg(exports.testFunc);

  assert_throws_js(TypeError, () => exports.concreteFuncArg(exports.testFunc2));

  assert_throws_js(TypeError, () => exports.concreteFuncArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.concreteFuncArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.concreteFuncArg(42));

  assert_throws_js(TypeError, () => exports.concreteFuncArg(42n));

  assert_throws_js(TypeError, () => exports.concreteFuncArg("foo"));

  assert_throws_js(TypeError, () => exports.concreteFuncArg({}));

  assert_throws_js(TypeError, () => exports.concreteFuncArg(() => {}));

  assert_throws_js(TypeError, () => exports.concreteFuncArg(null));

  exports.concreteFuncNullableArg(null);

  exports.concreteFuncNullableArg(exports.testFunc);

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(exports.testFunc2));

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(exports.makeArray()));

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(exports.makeStruct()));

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(42));

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(42n));

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg("foo"));

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg({}));

  assert_throws_js(TypeError, () => exports.concreteFuncNullableArg(() => {}));

}, "concrete func casts");

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: