Bug: Type Parameters are not imported

.github/workflows/test.yml

@@ -13,12 +13,12 @@ jobs:
         working-directory: e2e/dependencies/consumer
         run: |
           cargo t 
-          tsc bindings/* --noEmit
+          tsc bindings/* --noEmit --noUnusedLocals --strict
       - name: dependencies e2e test with default export env
         working-directory: e2e/dependencies/consumer
         run: |
           TS_RS_EXPORT_DIR=custom-bindings cargo t 
-          tsc custom-bindings/* --noEmit
+          tsc custom-bindings/* --noEmit --noUnusedLocals --strict
   e2e-workspace:
     name: Run 'workspace' end-to-end test
     runs-on: ubuntu-latest
@@ -31,12 +31,30 @@ jobs:
         working-directory: e2e/workspace
         run: |
           cargo t 
-          tsc parent/bindings/* --noEmit
+          tsc parent/bindings/* --noEmit --noUnusedLocals --strict
       - name: workspace e2e with default export env
         working-directory: e2e/workspace
         run: |
           TS_RS_EXPORT_DIR=custom-bindings cargo t 
-          tsc parent/custom-bindings/* --noEmit
+          tsc parent/custom-bindings/* --noEmit --noUnusedLocals --strict
+  e2e-example:
+    name: End-to-end test example
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: example e2e test
+        working-directory: example
+        run: |
+          cargo t 
+          tsc bindings/* --noEmit
+      - name: example e2e with default export env
+        working-directory: example
+        run: |
+          TS_RS_EXPORT_DIR=custom-bindings cargo t 
+          tsc custom-bindings/* --noEmit --noUnusedLocals --strict
 
   readme-up-to-date:
     name: Check that README.md is up-to-date
@@ -60,11 +78,13 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --no-default-features --manifest-path ts-rs/Cargo.toml
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --all-features --manifest-path ts-rs/Cargo.toml
+      - name: No features
+        run: |
+          cargo test --no-default-features
+          shopt -s globstar
+          tsc ts-rs/tests-out/**/*.ts --noEmit --noUnusedLocals
+      - name: All features
+        run: |
+          cargo test --all-features
+          shopt -s globstar
+          tsc ts-rs/tests-out/**/*.ts --noEmit --noUnusedLocals --strict

CHANGELOG.md

@@ -1,19 +1,25 @@
 # master
 
-### Breaking 
+### Breaking
+
 - Export types as `type` instead of `ìnterface` ([#203](https://github.com/Aleph-Alpha/ts-rs/pull/203))
 - Automatically export all dependencies when using `#[ts(export)]`, add `TS::dependency_types()` ([#221](https://github.com/Aleph-Alpha/ts-rs/pull/221))
 - Remove support for "skip_serializing", "skip_serializing_if" and "skip_deserializing". ([#204](https://github.com/Aleph-Alpha/ts-rs/pull/204))
-    - Initially supporting these by skipping a field was a mistake. If a user wishes to skip a field, they can still
-      annotate it with `#[ts(skip)]`
-
+  - Initially supporting these by skipping a field was a mistake. If a user wishes to skip a field, they can still
+    annotate it with `#[ts(skip)]`
+- Added `TS::dependency_types()` ([#221](https://github.com/Aleph-Alpha/ts-rs/pull/221))
+- Added `TS::generics()` ([#241](https://github.com/Aleph-Alpha/ts-rs/pull/241))
+- Added `TS::WithoutGenerics` ([#241](https://github.com/Aleph-Alpha/ts-rs/pull/241))
+- `Result`, `Option`, `HashMap` and `Vec` had their implementations of `TS` changed ([#241](https://github.com/Aleph-Alpha/ts-rs/pull/241))
+
 ### Features
+
 - Implement `#[ts(as = "..")]` ([#174](https://github.com/Aleph-Alpha/ts-rs/pull/174))
 - For small arrays, generate tuples instead of `Array<T>` ([#209](https://github.com/Aleph-Alpha/ts-rs/pull/209))
 - Implement `#[ts(optional = nullable)]` ([#213](https://github.com/Aleph-Alpha/ts-rs/pull/213))
 - Allow inlining of fields with generic types ([#212](https://github.com/Aleph-Alpha/ts-rs/pull/212), [#215](https://github.com/Aleph-Alpha/ts-rs/pull/215), [#216](https://github.com/Aleph-Alpha/ts-rs/pull/216))
 - Allow flattening enum fields ([#206](https://github.com/Aleph-Alpha/ts-rs/pull/206))
-- Add `semver-impl` cargo feature with support for the *semver* crate ([#176](https://github.com/Aleph-Alpha/ts-rs/pull/176))
+- Add `semver-impl` cargo feature with support for the _semver_ crate ([#176](https://github.com/Aleph-Alpha/ts-rs/pull/176))
 - Support `HashMap` with custom hashers ([#173](https://github.com/Aleph-Alpha/ts-rs/pull/173))
 - Add `import-esm` cargo feature to import files with a `.js` extension ([#192](https://github.com/Aleph-Alpha/ts-rs/pull/192))
 - Implement `#[ts(...)]` equivalents for `#[serde(tag = "...")]`, `#[serde(tag = "...", content = "...")]` and `#[serde(untagged)]` ([#227](https://github.com/Aleph-Alpha/ts-rs/pull/227))
@@ -22,7 +28,8 @@
 - Export Rust doc comments/attributes on structs/enums as TSDoc strings ([#187](https://github.com/Aleph-Alpha/ts-rs/pull/187))
 
 ### Fixes
+
 - fix `#[ts(skip)]` and `#[serde(skip)]` in variants of adjacently or internally tagged enums ([#231](https://github.com/Aleph-Alpha/ts-rs/pull/231))
 - `rename_all` with `camelCase` produces wrong names if fields were already in camelCase ([#198](https://github.com/Aleph-Alpha/ts-rs/pull/198))
 - Improve support for references ([#199](https://github.com/Aleph-Alpha/ts-rs/pull/199))
-
+- Generic type aliases generate correctly ([#233](https://github.com/Aleph-Alpha/ts-rs/pull/233))

e2e/dependencies/consumer/src/main.rs

@@ -9,6 +9,18 @@ struct ConsumerType {
     pub ty2_2: LibraryType2<&'static Self>,
     pub ty2_3: LibraryType2<LibraryType2<Box<ConsumerType>>>,
     pub ty2_4: LibraryType2<LibraryType2<LibraryType1>>,
+    pub ty2_5: LibraryType2<LibraryType3>,
 }
 
+#[derive(TS)]
+#[ts(export)]
+struct T0;
+
+#[derive(TS)]
+#[ts(export)]
+struct T1 {
+    t0: Option<T0>
+}
+
+
 fn main() {}

e2e/dependencies/dependency1/src/lib.rs

@@ -9,3 +9,6 @@ pub struct LibraryType1 {
 pub struct LibraryType2<T> {
     pub t: T
 }
+
+#[derive(TS)]
+pub struct LibraryType3;

macros/src/deps.rs

@@ -16,6 +16,9 @@ impl Dependencies {
     /// If the type is transparent, then we'll get resolve the child dependencies during runtime.
     pub fn push(&mut self, ty: &Type) {
         self.0.push(quote![.push::<#ty>()]);
+        self.0.push(quote![
+            .extend(<#ty as ts_rs::TS>::generics())
+        ]);
     }
 
     pub fn append(&mut self, other: Dependencies) {

macros/src/lib.rs

@@ -8,8 +8,7 @@ use syn::{
     TypeParam, WhereClause,
 };
 
-use crate::deps::Dependencies;
-use crate::utils::format_generics;
+use crate::{deps::Dependencies, utils::format_generics};
 
 #[macro_use]
 mod utils;
@@ -47,9 +46,9 @@ impl DerivedTS {
             }
         };
 
-        let export = self.export.then(
-            || self.generate_export_test(&rust_ty, &generics)
-        );
+        let export = self
+            .export
+            .then(|| self.generate_export_test(&rust_ty, &generics));
 
         let docs = match &*self.docs {
             "" => None,
@@ -58,24 +57,28 @@ impl DerivedTS {
 
         let ident = self.ts_name.clone();
         let impl_start = generate_impl_block_header(&rust_ty, &generics);
+        let assoc_type = generate_assoc_type(&rust_ty, &generics);
         let name = self.generate_name_fn();
         let inline = self.generate_inline_fn();
         let decl = self.generate_decl_fn(&rust_ty);
         let dependencies = &self.dependencies;
+        let generics_fn = self.generate_generics_fn();
 
         quote! {
             #impl_start {
+                #assoc_type
                 const EXPORT_TO: Option<&'static str> = Some(#export_to);
 
                 fn ident() -> String {
                     #ident.to_owned()
                 }
-                
+
                 #get_export_to
                 #docs
                 #name
                 #decl
                 #inline
+                #generics_fn
 
                 #[allow(clippy::unused_unit)]
                 fn dependency_types() -> impl ts_rs::typelist::TypeList
@@ -140,6 +143,7 @@ impl DerivedTS {
                     }
                 }
                 impl TS for #generics {
+                    type WithoutGenerics = #generics;
                     fn name() -> String { stringify!(#generics).to_owned() }
                     fn transparent() -> bool { false }
                 }
@@ -148,10 +152,11 @@ impl DerivedTS {
     }
 
     fn generate_export_test(&self, rust_ty: &Ident, generics: &Generics) -> TokenStream {
-        let test_fn = format_ident!("export_bindings_{}", rust_ty.to_string().to_lowercase());
-        let generic_params = generics
-            .type_params()
-            .map(|_| quote! { ts_rs::Dummy });
+        let test_fn = format_ident!(
+            "export_bindings_{}",
+            rust_ty.to_string().to_lowercase().replace("r#", "")
+        );
+        let generic_params = generics.type_params().map(|_| quote! { ts_rs::Dummy });
         let ty = quote!(<#rust_ty<#(#generic_params),*> as ts_rs::TS>);
 
         quote! {
@@ -163,12 +168,29 @@ impl DerivedTS {
         }
     }
 
+    fn generate_generics_fn(&self) -> TokenStream {
+        let generics = self
+            .generics
+            .type_params()
+            .map(|TypeParam { ident, .. }| quote![.push::<#ident>().extend(<#ident as ts_rs::TS>::generics())]);
+        quote! {
+            #[allow(clippy::unused_unit)]
+            fn generics() -> impl ts_rs::typelist::TypeList
+            where
+                Self: 'static,
+            {
+                use ts_rs::typelist::TypeList;
+                ()#(#generics)*
+            }
+        }
+    }
+
     fn generate_name_fn(&self) -> TokenStream {
         let name = self.name_with_generics();
         quote! {
-             fn name() -> String {
-                 #name
-             }
+            fn name() -> String {
+                #name
+            }
         }
     }
 
@@ -211,8 +233,9 @@ impl DerivedTS {
             //
             // We keep const parameters as they are, since there's no sensible default value we can
             // use instead. This might be something to change in the future.
-            G::Type(TypeParam { ident, .. }) |
-            G::Const(ConstParam { ident, .. }) => Some(quote!(#ident)),
+            G::Type(TypeParam { ident, .. }) | G::Const(ConstParam { ident, .. }) => {
+                Some(quote!(#ident))
+            }
         });
         quote! {
             fn decl_concrete() -> String {
@@ -228,6 +251,26 @@ impl DerivedTS {
     }
 }
 
+fn generate_assoc_type(rust_ty: &Ident, generics: &Generics) -> TokenStream {
+    use GenericParam as G;
+
+    let generics_params = generics
+        .params
+        .iter()
+        .map(|x| match x {
+            G::Type(_) => quote! { ts_rs::Dummy },
+            G::Const(ConstParam { ident, .. }) => quote! { #ident },
+            G::Lifetime(LifetimeParam { lifetime, .. }) => quote! { #lifetime },
+        })
+        .collect::<Vec<_>>();
+
+    if generics_params.is_empty() {
+        quote! { type WithoutGenerics = #rust_ty; }
+    } else {
+        quote! { type WithoutGenerics = #rust_ty<#(#generics_params),*>; }
+    }
+}
+
 // generate start of the `impl TS for #ty` block, up to (excluding) the open brace
 fn generate_impl_block_header(ty: &Ident, generics: &Generics) -> TokenStream {
     use GenericParam as G;

macros/src/types/enum.rs

@@ -5,8 +5,7 @@ use syn::{Fields, Generics, ItemEnum, Type, Variant};
 use crate::{
     attr::{EnumAttr, FieldAttr, StructAttr, Tagged, VariantAttr},
     deps::Dependencies,
-    DerivedTS,
-    types,
+    types, DerivedTS,
 };
 
 pub(crate) fn r#enum_def(s: &ItemEnum) -> syn::Result<DerivedTS> {
@@ -113,8 +112,6 @@ fn format_variant(
                     ..
                 } = FieldAttr::from_attrs(&unnamed.unnamed[0].attrs)?;
 
-
-
                 if skip {
                     quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #name))
                 } else {
@@ -128,7 +125,7 @@ fn format_variant(
                         (None, None) => {
                             let ty = &unnamed.unnamed[0].ty;
                             quote!(<#ty as ts_rs::TS>::name())
-                        },
+                        }
                     };
 
                     quote!(format!("{{ \"{}\": \"{}\", \"{}\": {} }}", #tag, #name, #content, #ty))
@@ -178,7 +175,7 @@ fn format_variant(
                             (None, None) => {
                                 let ty = &unnamed.unnamed[0].ty;
                                 quote!(<#ty as ts_rs::TS>::name())
-                            },
+                            }
                         };
 
                         quote!(format!("{{ \"{}\": \"{}\" }} & {}", #tag, #name, #ty))

macros/src/types/named.rs

@@ -5,8 +5,8 @@ use syn::{Field, FieldsNamed, GenericArgument, Generics, PathArguments, Result,
 use crate::{
     attr::{FieldAttr, Inflection, Optional, StructAttr},
     deps::Dependencies,
-    DerivedTS,
     utils::{raw_name_to_ts_field, to_ts_ident},
+    DerivedTS,
 };
 
 pub(crate) fn named(

macros/src/utils.rs

@@ -1,8 +1,11 @@
 use std::convert::TryFrom;
 
 use proc_macro2::{Ident, TokenStream};
-use syn::{Attribute, Error, Expr, ExprLit, GenericParam, Generics, Lit, Meta, Result, spanned::Spanned};
 use quote::quote;
+use syn::{
+    spanned::Spanned, Attribute, Error, Expr, ExprLit, GenericParam, Generics, Lit, Meta, Result,
+};
+
 use crate::deps::Dependencies;
 
 macro_rules! syn_err {
@@ -26,11 +29,16 @@ macro_rules! impl_parse {
             fn parse($input: syn::parse::ParseStream) -> syn::Result<Self> {
                 let mut $out = $i::default();
                 loop {
+                    let span = $input.span();
                     let key: Ident = $input.call(syn::ext::IdentExt::parse_any)?;
                     match &*key.to_string() {
                         $($k => $e,)*
                         #[allow(unreachable_patterns)]
-                        _ => syn_err!($input.span(); "unexpected attribute")
+                        x => syn_err!(
+                            span;
+                            "Unknown attribute \"{x}\". Allowed attributes are: {}",
+                            [$(stringify!($k),)*].join(", ")
+                        )
                     }
 
                     match $input.is_empty() {
@@ -65,7 +73,7 @@ pub fn raw_name_to_ts_field(value: String) -> String {
     let valid_chars = value
         .chars()
         .all(|c| c.is_alphanumeric() || c == '_' || c == '$');
-    
+
     let does_not_start_with_digit = value
         .chars()
         .next()
@@ -140,7 +148,7 @@ pub fn parse_docs(attrs: &[Attribute]) -> Result<String> {
         .map(|attr| {
             attr.map(|line| match line.trim() {
                 "" => " *".to_owned(),
-                _ => format!(" *{}", line.trim_end())
+                _ => format!(" *{}", line.trim_end()),
             })
         })
         .collect::<Result<Vec<_>>>()?;