From bd5da44d5d5baf14a8b23656542dfa124f06ad16 Mon Sep 17 00:00:00 2001 From: Oliver T Date: Fri, 18 Aug 2023 16:26:52 -0400 Subject: [PATCH] Remove class wrap for constructors in Rust exports After #1594 constructors of Rust exported structs started using class wrapping when generating JS shims. Wrapping erases prototype information from the object instance in JS and as a result it is not possible to override methods (via inheritance) of the generated class. Additionally, some checks to ensure constructors always return an instance of `Self` were lost. This PR is rebased from #3561, it passes the constructor information from the `Builder` into the instruction translation function which is then used to modify the generated bindings. The `return` statement is also removed instead the value is directly attached to the instance. Signed-off-by: Oliver T --- crates/cli-support/src/js/binding.rs | 48 ++++++++++++--- crates/cli/tests/reference/builder.d.ts | 11 ++++ crates/cli/tests/reference/builder.js | 61 +++++++++++++++++++ crates/cli/tests/reference/builder.rs | 11 ++++ crates/cli/tests/reference/builder.wat | 10 +++ crates/cli/tests/reference/constructor.d.ts | 10 +++ crates/cli/tests/reference/constructor.js | 52 ++++++++++++++++ crates/cli/tests/reference/constructor.rs | 13 ++++ crates/cli/tests/reference/constructor.wat | 10 +++ crates/cli/tests/wasm-bindgen/main.rs | 27 ++++++++ .../attributes/on-rust-exports/constructor.md | 38 ++++++++++++ 11 files changed, 281 insertions(+), 10 deletions(-) create mode 100644 crates/cli/tests/reference/builder.d.ts create mode 100644 crates/cli/tests/reference/builder.js create mode 100644 crates/cli/tests/reference/builder.rs create mode 100644 crates/cli/tests/reference/builder.wat create mode 100644 crates/cli/tests/reference/constructor.d.ts create mode 100644 crates/cli/tests/reference/constructor.js create mode 100644 crates/cli/tests/reference/constructor.rs create mode 100644 crates/cli/tests/reference/constructor.wat diff --git a/crates/cli-support/src/js/binding.rs b/crates/cli-support/src/js/binding.rs index 83a04f92fb6..6a204fc9d1b 100644 --- a/crates/cli-support/src/js/binding.rs +++ b/crates/cli-support/src/js/binding.rs @@ -166,7 +166,12 @@ impl<'a, 'b> Builder<'a, 'b> { // more JIT-friendly. The generated code should be equivalent to the // wasm interface types stack machine, however. for instr in instructions { - instruction(&mut js, &instr.instr, &mut self.log_error)?; + instruction( + &mut js, + &instr.instr, + &mut self.log_error, + &self.constructor, + )?; } assert_eq!(js.stack.len(), adapter.results.len()); @@ -174,7 +179,11 @@ impl<'a, 'b> Builder<'a, 'b> { 0 => {} 1 => { let val = js.pop(); - js.prelude(&format!("return {};", val)); + if self.constructor.is_some() { + js.prelude(&format!("this.__wbg_ptr = {}", val)); + } else { + js.prelude(&format!("return {};", val)); + } } // TODO: this should be pretty trivial to support (commented out @@ -537,7 +546,12 @@ impl<'a, 'b> JsBuilder<'a, 'b> { } } -fn instruction(js: &mut JsBuilder, instr: &Instruction, log_error: &mut bool) -> Result<(), Error> { +fn instruction( + js: &mut JsBuilder, + instr: &Instruction, + log_error: &mut bool, + constructor: &Option, +) -> Result<(), Error> { match instr { Instruction::ArgGet(n) => { let arg = js.arg(*n).to_string(); @@ -987,18 +1001,32 @@ fn instruction(js: &mut JsBuilder, instr: &Instruction, log_error: &mut bool) -> } Instruction::RustFromI32 { class } => { - js.cx.require_class_wrap(class); let val = js.pop(); - js.push(format!("{}.__wrap({})", class, val)); + if let Some(name) = constructor { + if name != class { + bail!("constructor for `{}` cannot return `{}`", name, class); + } + js.push(format!("{} >>> 0;", val)); + } else { + js.cx.require_class_wrap(class); + js.push(format!("{}.__wrap({})", class, val)); + } } Instruction::OptionRustFromI32 { class } => { - js.cx.require_class_wrap(class); let val = js.pop(); - js.push(format!( - "{0} === 0 ? undefined : {1}.__wrap({0})", - val, class, - )) + if let Some(name) = constructor { + if name != class { + bail!("constructor for `{}` cannot return `{}`", name, class); + } + js.push(format!("{val} === 0 ? 0 : ({val} >>> 0);")); + } else { + js.cx.require_class_wrap(class); + js.push(format!( + "{0} === 0 ? undefined : {1}.__wrap({0})", + val, class, + )) + } } Instruction::CachedStringLoad { diff --git a/crates/cli/tests/reference/builder.d.ts b/crates/cli/tests/reference/builder.d.ts new file mode 100644 index 00000000000..ede348c9632 --- /dev/null +++ b/crates/cli/tests/reference/builder.d.ts @@ -0,0 +1,11 @@ +/* tslint:disable */ +/* eslint-disable */ +/** +*/ +export class ClassBuilder { + free(): void; +/** +* @returns {ClassBuilder} +*/ + static builder(): ClassBuilder; +} diff --git a/crates/cli/tests/reference/builder.js b/crates/cli/tests/reference/builder.js new file mode 100644 index 00000000000..3402667dd0d --- /dev/null +++ b/crates/cli/tests/reference/builder.js @@ -0,0 +1,61 @@ +let wasm; +export function __wbg_set_wasm(val) { + wasm = val; +} + + +const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder; + +let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +let cachedUint8Memory0 = null; + +function getUint8Memory0() { + if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) { + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8Memory0; +} + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} +/** +*/ +export class ClassBuilder { + + static __wrap(ptr) { + ptr = ptr >>> 0; + const obj = Object.create(ClassBuilder.prototype); + obj.__wbg_ptr = ptr; + + return obj; + } + + __destroy_into_raw() { + const ptr = this.__wbg_ptr; + this.__wbg_ptr = 0; + + return ptr; + } + + free() { + const ptr = this.__destroy_into_raw(); + wasm.__wbg_classbuilder_free(ptr); + } + /** + * @returns {ClassBuilder} + */ + static builder() { + const ret = wasm.classbuilder_builder(); + return ClassBuilder.__wrap(ret); + } +} + +export function __wbindgen_throw(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + diff --git a/crates/cli/tests/reference/builder.rs b/crates/cli/tests/reference/builder.rs new file mode 100644 index 00000000000..317f20cad92 --- /dev/null +++ b/crates/cli/tests/reference/builder.rs @@ -0,0 +1,11 @@ +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub struct ClassBuilder(()); + +#[wasm_bindgen] +impl ClassBuilder { + pub fn builder() -> ClassBuilder { + ClassBuilder(()) + } +} diff --git a/crates/cli/tests/reference/builder.wat b/crates/cli/tests/reference/builder.wat new file mode 100644 index 00000000000..cd38fc7fc6a --- /dev/null +++ b/crates/cli/tests/reference/builder.wat @@ -0,0 +1,10 @@ +(module + (type (;0;) (func (result i32))) + (type (;1;) (func (param i32))) + (func $__wbg_classbuilder_free (;0;) (type 1) (param i32)) + (func $classbuilder_builder (;1;) (type 0) (result i32)) + (memory (;0;) 17) + (export "memory" (memory 0)) + (export "__wbg_classbuilder_free" (func $__wbg_classbuilder_free)) + (export "classbuilder_builder" (func $classbuilder_builder)) +) diff --git a/crates/cli/tests/reference/constructor.d.ts b/crates/cli/tests/reference/constructor.d.ts new file mode 100644 index 00000000000..f35e8c72fa1 --- /dev/null +++ b/crates/cli/tests/reference/constructor.d.ts @@ -0,0 +1,10 @@ +/* tslint:disable */ +/* eslint-disable */ +/** +*/ +export class ClassConstructor { + free(): void; +/** +*/ + constructor(); +} diff --git a/crates/cli/tests/reference/constructor.js b/crates/cli/tests/reference/constructor.js new file mode 100644 index 00000000000..f92a8140703 --- /dev/null +++ b/crates/cli/tests/reference/constructor.js @@ -0,0 +1,52 @@ +let wasm; +export function __wbg_set_wasm(val) { + wasm = val; +} + + +const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder; + +let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +let cachedUint8Memory0 = null; + +function getUint8Memory0() { + if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) { + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8Memory0; +} + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} +/** +*/ +export class ClassConstructor { + + __destroy_into_raw() { + const ptr = this.__wbg_ptr; + this.__wbg_ptr = 0; + + return ptr; + } + + free() { + const ptr = this.__destroy_into_raw(); + wasm.__wbg_classconstructor_free(ptr); + } + /** + */ + constructor() { + const ret = wasm.classconstructor_new(); + this.__wbg_ptr = ret >>> 0; + } +} + +export function __wbindgen_throw(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + diff --git a/crates/cli/tests/reference/constructor.rs b/crates/cli/tests/reference/constructor.rs new file mode 100644 index 00000000000..ca4bac080b3 --- /dev/null +++ b/crates/cli/tests/reference/constructor.rs @@ -0,0 +1,13 @@ +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub struct ClassConstructor(()); + +#[wasm_bindgen] +impl ClassConstructor { + + #[wasm_bindgen(constructor)] + pub fn new() -> ClassConstructor { + ClassConstructor(()) + } +} diff --git a/crates/cli/tests/reference/constructor.wat b/crates/cli/tests/reference/constructor.wat new file mode 100644 index 00000000000..a5596470321 --- /dev/null +++ b/crates/cli/tests/reference/constructor.wat @@ -0,0 +1,10 @@ +(module + (type (;0;) (func (result i32))) + (type (;1;) (func (param i32))) + (func $__wbg_classconstructor_free (;0;) (type 1) (param i32)) + (func $classconstructor_new (;1;) (type 0) (result i32)) + (memory (;0;) 17) + (export "memory" (memory 0)) + (export "__wbg_classconstructor_free" (func $__wbg_classconstructor_free)) + (export "classconstructor_new" (func $classconstructor_new)) +) diff --git a/crates/cli/tests/wasm-bindgen/main.rs b/crates/cli/tests/wasm-bindgen/main.rs index 055fad5ed1f..e2adb031640 100644 --- a/crates/cli/tests/wasm-bindgen/main.rs +++ b/crates/cli/tests/wasm-bindgen/main.rs @@ -431,3 +431,30 @@ fn function_table_preserved() { .wasm_bindgen(""); cmd.assert().success(); } + +#[test] +fn constructor_cannot_return_foreign_struct() { + let (mut cmd, _out_dir) = Project::new("constructor_cannot_return_foreign_struct") + .file( + "src/lib.rs", + r#" + use wasm_bindgen::prelude::*; + + #[wasm_bindgen] + pub struct Foo(()); + + #[wasm_bindgen] + pub struct Bar(()); + + #[wasm_bindgen] + impl Foo { + #[wasm_bindgen(constructor)] + pub fn new() -> Bar { + Bar(()) + } + } + "#, + ) + .wasm_bindgen("--target web"); + cmd.assert().failure(); +} diff --git a/guide/src/reference/attributes/on-rust-exports/constructor.md b/guide/src/reference/attributes/on-rust-exports/constructor.md index 1d6fcf4f625..4b154b7cc45 100644 --- a/guide/src/reference/attributes/on-rust-exports/constructor.md +++ b/guide/src/reference/attributes/on-rust-exports/constructor.md @@ -32,3 +32,41 @@ import { Foo } from './my_module'; const f = new Foo(); console.log(f.get_contents()); ``` + +## Caveats + +Starting from v0.2.48 there is a bug in the `wasm-bindgen` which breaks inheritance of exported Rust structs from JavaScript side (see [#3213](https://github.com/rustwasm/wasm-bindgen/issues/3213)). If you want to inherit from a Rust struct such as: + +```rust +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub struct Parent { + msg: String, +} + +#[wasm_bindgen] +impl Parent { + #[wasm_bindgen(constructor)] + fn new() -> Self { + Parent { + msg: String::from("Hello from Parent!"), + } + } +} +``` + +You will need to reset the prototype of `this` back to the `Child` class prototype after calling the `Parent`'s constructor via `super`. + +```js +import { Parent } from './my_module'; + +class Child extends Parent { + constructor() { + super(); + Object.setPrototypeOf(this, Child.prototype); + } +} +``` + +This is no longer required as of v0.2.88.