Add Ts<T> wrapper type to avoid memory leaks (#71)

Add `Ts<T>` wrapper type to avoid memory leaks. This addresses #65

* Add a test for conversions of Ts<T>

* Add an e2e test for Ts<T>

* Return better error messages for Ts<T> conversions

* include_str! README.md to lib.rs as documentation and doctestify its examples

* Update expandtest for rustc 1.88.0

* Deprecate #[tsify(into_wasm_abi, from_wasm_abi)]

There seems to be no way to emit #[deprecated] warnings.

* Actually emit a #[deprecated] from the macro for into_wasm_abi/from_wasm_abi attributes

Author: cormacrelf

README.md

@@ -25,22 +25,27 @@ wasm-bindgen = { version = "0.2" }
 ```rust
 use serde::{Deserialize, Serialize};
 use tsify::Tsify;
+use tsify::Ts;
 use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsError;
 
 #[derive(Tsify, Serialize, Deserialize)]
-#[tsify(into_wasm_abi, from_wasm_abi)]
 pub struct Point {
     x: i32,
     y: i32,
 }
 
 #[wasm_bindgen]
-pub fn into_js() -> Point {
-    Point { x: 0, y: 0 }
+pub fn into_js() -> Result<Ts<Point>, JsError> {
+    let point = Point { x: 0, y: 0 };
+    Ok(point.into_ts()?)
 }
 
 #[wasm_bindgen]
-pub fn from_js(point: Point) {}
+pub fn from_js(point: Ts<Point>) -> Result<(), JsError> {
+    let point: Point = point.to_rust()?;
+    Ok(())
+}
 ```
 
 Will generate the following `.d.ts` file:
@@ -73,8 +78,8 @@ This is the behavior due to [`typescript_custom_section`](https://rustwasm.githu
 
 Tsify container attributes
 
--   `into_wasm_abi` implements `IntoWasmAbi` and `OptionIntoWasmAbi`. This can be converted directly from Rust to JS via `serde_json` or `serde-wasm-bindgen`.
--   `from_wasm_abi` implements `FromWasmAbi` and `OptionFromWasmAbi`. This is the opposite operation of the above.
+-   `into_wasm_abi` (deprecated) implements `IntoWasmAbi` and `OptionIntoWasmAbi`. This can be converted directly from Rust to JS via `serde_json` or `serde-wasm-bindgen`. Deprecated in favour of using `Ts<T>` as on function parameters and return type.
+-   `from_wasm_abi` (deprecated) implements `FromWasmAbi` and `OptionFromWasmAbi`. This is the opposite operation of the above. Deprecated in favour of using `Ts<T>` as on function parameters and return type.
 -   `namespace` generates a namespace for the enum variants.
 -   `type` overrides at the container level.
 -   `type_params` overrides params at the container level.
@@ -128,6 +133,8 @@ export interface Foo {
 ## Optional Properties
 
 ```rust
+use tsify::Tsify;
+
 #[derive(Tsify)]
 struct Optional {
     #[tsify(optional)]
@@ -152,6 +159,8 @@ export interface Optional {
 ## Enum
 
 ```rust
+use tsify::Tsify;
+
 #[derive(Tsify)]
 enum Color {
     Red,
@@ -180,6 +189,8 @@ export type Color =
 ## Enum with namespace
 
 ```rust
+use tsify::Tsify;
+
 #[derive(Tsify)]
 #[tsify(namespace)]
 enum Color {

src/error.rs

@@ -0,0 +1,47 @@
+use std::fmt;
+
+/// An error type wrapping serialization or deserialization errors from either `serde_json` or
+/// `serde_wasm_bindgen`, depending on whether the `json` or `js` feature is enabled.
+///
+#[derive(Debug)]
+pub struct Error {
+    // All private internals
+    //
+    /// XXX: May want to put type-name printing behind an off-by-default feature flag,
+    /// as it does add bloat that some users might not want.
+    pub(crate) type_name: &'static str,
+    /// true -> During deserialization; false -> during serialization
+    pub(crate) de: bool,
+    pub(crate) inner: SerializationError,
+}
+
+#[cfg(all(feature = "json", not(feature = "js")))]
+type SerializationError = serde_json::Error;
+#[cfg(feature = "js")]
+type SerializationError = serde_wasm_bindgen::Error;
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.de {
+            write!(
+                f,
+                "Failed to deserialize JsValue into type `{}`: {}",
+                self.type_name, self.inner
+            )
+        } else {
+            write!(
+                f,
+                "Failed to serialize type `{}` into JsValue: {}",
+                self.type_name, self.inner
+            )
+        }
+    }
+}
+
+/// We implement [std::error::Error] so you can use `?` in `-> Result<_,
+/// wasm_bindgen::JsError>` functions to automatically throw.
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.inner)
+    }
+}

src/lib.rs

@@ -1,10 +1,16 @@
+#![doc = include_str!("../README.md")]
 #![allow(clippy::wrong_self_convention)]
 
 #[cfg(not(any(feature = "json", feature = "js")))]
 compile_error!(
     "Either the \"json\" or \"js\" feature must be enabled for tsify to function properly"
 );
 
+mod ts;
+pub use ts::Ts;
+mod error;
+pub use error::Error;
+
 #[cfg(all(feature = "json", not(feature = "js")))]
 pub use gloo_utils::format::JsValueSerdeExt;
 #[cfg(feature = "js")]
@@ -72,4 +78,16 @@ pub trait Tsify {
     {
         serde_wasm_bindgen::from_value(js.into())
     }
+
+    /// Calls `Ts::from_rust` on self, returning a `Result<Ts<Self>, crate::Error>`.
+    ///
+    /// This can (and should) be used with the [`-> Result<_, JsError>`][wasm_bindgen::JsError]
+    /// pattern from wasm-bindgen to automatically throw any Err value returned.
+    fn into_ts(&self) -> Result<Ts<Self>, crate::Error>
+    where
+        Self: Sized,
+        Self: serde::Serialize,
+    {
+        Ts::from_rust(self)
+    }
 }