fix: Add logic to remove default parameters from generics for fix #67

Author: madonoharu

tests/generics.rs

@@ -2,6 +2,7 @@
 
 use indoc::indoc;
 use pretty_assertions::assert_eq;
+use serde::{Deserialize, Serialize};
 use tsify::Tsify;
 
 #[test]
@@ -140,3 +141,92 @@ fn test_generic_enum_with_namespace() {
 
     assert_eq!(GenericEnum::<(), ()>::DECL, expected);
 }
+
+#[test]
+fn test_generics_with_default_params() {
+    #[derive(Serialize, Tsify)]
+    #[tsify(into_wasm_abi)]
+    struct SerNamedTuple<A = i32, B = String, C = ()>(A, B, C);
+
+    let expected = indoc! {r#"
+        export type SerNamedTuple<A, B, C> = [A, B, C];"#
+    };
+
+    assert_eq!(SerNamedTuple::<(), (), ()>::DECL, expected);
+
+    #[derive(Deserialize, Tsify)]
+    #[tsify(from_wasm_abi)]
+    struct DeNamedTuple<A = i32, B = String, C = ()>(A, B, C);
+
+    let expected = indoc! {r#"
+        export type SerNamedTuple<A, B, C> = [A, B, C];"#
+    };
+
+    assert_eq!(SerNamedTuple::<(), (), ()>::DECL, expected);
+
+    #[derive(Serialize, Tsify)]
+    #[tsify(into_wasm_abi)]
+    struct SerNamedMap<A, B = (), C = i32> {
+        a: A,
+        b: B,
+        c: C,
+    }
+
+    let expected = indoc! {r#"
+        export interface SerNamedMap<A, B, C> {
+            a: A;
+            b: B;
+            c: C;
+        }"#
+    };
+
+    assert_eq!(SerNamedMap::<(), (), ()>::DECL, expected);
+
+    #[derive(Deserialize, Tsify)]
+    #[tsify(from_wasm_abi)]
+    struct DeNamedMap<A, B = (), C = i32> {
+        a: A,
+        b: B,
+        c: C,
+    }
+
+    let expected = indoc! {r#"
+        export interface DeNamedMap<A, B, C> {
+            a: A;
+            b: B;
+            c: C;
+        }"#
+    };
+
+    assert_eq!(DeNamedMap::<(), (), ()>::DECL, expected);
+
+    #[derive(Serialize, Tsify)]
+    #[tsify(into_wasm_abi)]
+    enum SerEnum<A, B = (), C = i32> {
+        Unit,
+        NewType(A),
+        Seq(i8, B),
+        Map { a: i8, b: B, c: C },
+    }
+
+    let expected = indoc! {r#"
+        export type SerEnum<A, B, C> = "Unit" | { NewType: A } | { Seq: [number, B] } | { Map: { a: number; b: B; c: C } };"#
+    };
+
+    assert_eq!(SerEnum::<(), (), ()>::DECL, expected);
+
+    #[derive(Deserialize, Tsify)]
+    #[tsify(from_wasm_abi)]
+    enum DeEnum<A, B = (), C = i32> {
+        Unit,
+        NewType(A),
+        Seq(i8, B),
+        Map { a: i8, b: B, c: C },
+    }
+
+    let expected = indoc! {r#"
+        export type DeEnum<A, B, C> = "Unit" | { NewType: A } | { Seq: [number, B] } | { Map: { a: number; b: B; c: C } };"#
+    };
+
+    assert_eq!(DeEnum::<(), (), ()>::DECL, expected);
+}

tsify-macros/src/container.rs

@@ -92,6 +92,28 @@ impl<'a> Container<'a> {
         self.serde_container.generics
     }
 
+    /// Remove the default from every type parameter because in the generated impls
+    /// they look like associated types: "error: associated type bindings are not
+    /// allowed here".
+    pub fn generics_without_defaults(&self) -> syn::Generics {
+        let generics = self.generics();
+        syn::Generics {
+            params: generics
+                .params
+                .iter()
+                .map(|param| match param {
+                    syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
+                        eq_token: None,
+                        default: None,
+                        ..param.clone()
+                    }),
+                    _ => param.clone(),
+                })
+                .collect(),
+            ..generics.clone()
+        }
+    }
+
     /// Information about the data fields of the type as parsed by Serde.
     pub fn serde_data(&self) -> &ast::Data<'_> {
         &self.serde_container.data

tsify-macros/src/wasm_bindgen.rs

@@ -9,7 +9,8 @@ pub fn expand(cont: &Container, decl: Decl) -> TokenStream {
     let ident = cont.ident();
 
     let decl_str = decl.to_string();
-    let (impl_generics, ty_generics, where_clause) = cont.generics().split_for_impl();
+    let generics = cont.generics_without_defaults();
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
     let typescript_custom_section = quote! {
         #[wasm_bindgen(typescript_custom_section)]
@@ -95,9 +96,9 @@ pub fn expand(cont: &Container, decl: Decl) -> TokenStream {
 fn expand_into_wasm_abi(cont: &Container) -> TokenStream {
     let ident = cont.ident();
     let serde_path = cont.serde_container.attrs.serde_path();
+    let mut generics = cont.generics_without_defaults();
+    let borrowed_generics = generics.clone();
 
-    let borrowed_generics = cont.generics();
-    let mut generics = cont.generics().clone();
     generics
         .make_where_clause()
         .predicates
@@ -202,7 +203,7 @@ fn expand_from_wasm_abi(cont: &Container) -> TokenStream {
     let ident = cont.ident();
     let serde_path = cont.serde_container.attrs.serde_path();
 
-    let mut generics = cont.generics().clone();
+    let mut generics = cont.generics_without_defaults();
 
     generics
         .make_where_clause()