Fix flatten generic by changing TS::name

macros/src/lib.rs

@@ -97,6 +97,7 @@ impl DerivedTS {
             .unwrap_or_else(TokenStream::new);
 
         let impl_start = generate_impl(&rust_ty, &generics);
+        let generic_idents = generics.type_params().map(|x| x.ident.clone());
         quote! {
             #impl_start {
                 const EXPORT_TO: Option<&'static str> = Some(#export_to);
@@ -108,7 +109,11 @@ impl DerivedTS {
                     #decl
                 }
                 fn name() -> String {
-                    #name.to_owned()
+                    let generics: Vec<String> = vec![#(<#generic_idents>::name()),*];
+                    match generics.is_empty() {
+                        true => #name.to_owned(),
+                        false => format!("{}<{}>", #name, generics.join(", ")),
+                    }
                 }
                 fn inline() -> String {
                     #inline

macros/src/types/generics.rs

@@ -64,15 +64,12 @@ pub fn format_type(ty: &Type, dependencies: &mut Dependencies, generics: &Generi
         }
 
         return quote!(
-            match <#generic_ident>::inline().as_str() {
-                // When exporting a generic, the default type used is `()`,
-                // which gives "null" when calling `.name()`. In this case, we
-                // want to preserve the type param's identifier as the name used
+            match <#generic_ident>::name().as_str() {
                 "null" => #generic_ident_str.to_owned(),
 
-                // If name is not "null", a type has been provided, so we use its
-                // name instead
-                x => x.to_owned()
+                x => {
+                    x.to_owned()
+                }
             }
         );
     }

ts-rs/src/lib.rs

@@ -298,7 +298,10 @@ pub trait TS {
 
     /// Name of this type in TypeScript, with type arguments.
     fn name_with_type_args(args: Vec<String>) -> String {
-        format!("{}<{}>", Self::name(), args.join(", "))
+        match Self::name().split_once('<') {
+            None => Self::name(),
+            Some(x) => format!("{}<{}>", x.0, args.join(", "))
+        }
     }
 
     /// Formats this types definition in TypeScript, e.g `{ user_id: number }`.
@@ -397,7 +400,10 @@ impl Dependency {
         let exported_to = T::get_export_to()?;
         Some(Dependency {
             type_id: TypeId::of::<T>(),
-            ts_name: T::name(),
+            ts_name: match T::name() {
+                x if !x.contains('<') => x,
+                x => x.split('<').next().unwrap().to_owned()
+            },
             exported_to,
         })
     }
@@ -535,7 +541,7 @@ impl<T: TS, E: TS> TS for Result<T, E> {
 
 impl<T: TS> TS for Vec<T> {
     fn name() -> String {
-        "Array".to_owned()
+        format!("Array<{}>", T::name())
     }
 
     fn inline() -> String {
@@ -561,7 +567,13 @@ impl<T: TS, const N: usize> TS for [T; N] {
             return Vec::<T>::name();
         }
 
-        "[]".to_owned()
+        format!(
+            "[{}]",
+            (0..N)
+                .map(|_| T::name())
+                .collect::<Box<[_]>>()
+                .join(", ")
+        )
     }
 
     fn name_with_type_args(args: Vec<String>) -> String {
@@ -610,7 +622,7 @@ impl<T: TS, const N: usize> TS for [T; N] {
 
 impl<K: TS, V: TS, H> TS for HashMap<K, V, H> {
     fn name() -> String {
-        "Record".to_owned()
+        format!("Record<{}, {}>", K::name(), V::name())
     }
 
     fn name_with_type_args(args: Vec<String>) -> String {

ts-rs/tests/generics.rs

@@ -256,7 +256,7 @@ fn default() {
         // #[ts(inline)]
         // xi2: X<i32>
     }
-    assert_eq!(Y::decl(), "type Y = { a1: A, a2: A<number>, }")
+    assert_eq!(Y::decl(), "type Y = { a1: A<string>, a2: A<number>, }")
 }
 
 #[test]
@@ -349,3 +349,36 @@ fn deeply_nested() {
          }"
     );
 }
+
+#[test]
+fn inline_generic_enum() {
+    #[derive(TS)]
+    struct OtherType<T>(T);
+
+    #[derive(TS)]
+    struct SomeType<T>(OtherType<T>);
+
+    #[derive(TS)]
+    enum MyEnum<A, B> {
+        VariantA(A),
+        VariantB(B)
+    }
+
+    #[derive(TS)]
+    struct Parent {
+        e: MyEnum<i32, i32>,
+        #[ts(inline)]
+        e1: MyEnum<i32, SomeType<String>>
+    }
+
+    // This fails!
+    // The #[ts(inline)] seems to inline recursively, so not only the definition of `MyEnum`, but
+    // also the definition of `SomeType`.
+    assert_eq!(
+        Parent::decl(),
+        "type Parent = { \
+            e: MyEnum<number, number>, \
+            e1: { \"VariantA\": number } | { \"VariantB\": SomeType<string> }, \
+        }"
+    );
+}

ts-rs/tests/type_alias.rs

@@ -0,0 +1,32 @@
+#![allow(dead_code)]
+
+use std::collections::HashMap;
+use ts_rs::TS;
+
+type TypeAlias = HashMap<String, String>;
+
+#[derive(TS)]
+enum Enum {
+    A(TypeAlias),
+    B(HashMap<String, String>),
+}
+
+#[derive(TS)]
+struct Struct {
+    a: TypeAlias,
+    b: HashMap<String, String>
+}
+
+#[test]
+fn type_alias() {
+    assert_eq!(
+        Enum::decl(),
+        r#"type Enum = { "A": Record<string, string> } | { "B": Record<string, string> };"#
+    );
+
+    assert_eq!(
+        Struct::decl(),
+        "type Struct = { a: Record<string, string>, b: Record<string, string>, }"
+    );
+}
+