diff --git a/macros/src/deps.rs b/macros/src/deps.rs new file mode 100644 index 0000000..02d34b1 --- /dev/null +++ b/macros/src/deps.rs @@ -0,0 +1,45 @@ +use proc_macro2::TokenStream; +use quote::{quote, ToTokens}; +use syn::Type; + +#[derive(Default)] +pub struct Dependencies(Vec); + +impl Dependencies { + /// Adds all dependencies from the given type + pub fn append_from(&mut self, ty: &Type) { + self.0 + .push(quote!(dependencies.append(&mut <#ty as ts_rs::TS>::dependencies());)); + } + + /// Adds the given type if it's *not* transparent. + /// If it is, all it's child dependencies are added instead. + pub fn push_or_append_from(&mut self, ty: &Type) { + self.0.push(quote! { + if <#ty as ts_rs::TS>::transparent() { + dependencies.append(&mut <#ty as ts_rs::TS>::dependencies()); + } else { + dependencies.push((std::any::TypeId::of::<#ty>(), <#ty as ts_rs::TS>::name())); + } + }); + } + + pub fn append(&mut self, other: Dependencies) { + self.0.push(quote! { + dependencies.append(&mut #other) + }) + } +} + +impl ToTokens for Dependencies { + fn to_tokens(&self, tokens: &mut TokenStream) { + let dependencies = &self.0; + tokens.extend(quote! { + { + let mut dependencies = vec![]; + #( #dependencies )* + dependencies + } + }) + } +} diff --git a/macros/src/lib.rs b/macros/src/lib.rs index e377e54..b47b4d9 100644 --- a/macros/src/lib.rs +++ b/macros/src/lib.rs @@ -4,18 +4,20 @@ use proc_macro2::{Ident, TokenStream}; use quote::quote; use syn::{parse_quote, spanned::Spanned, GenericParam, Generics, Item, Result, WhereClause}; +use crate::deps::Dependencies; #[macro_use] mod utils; mod attr; mod types; +mod deps; struct DerivedTS { name: String, inline: TokenStream, decl: TokenStream, inline_flattened: Option, - dependencies: TokenStream, + dependencies: Dependencies, } impl DerivedTS { diff --git a/macros/src/types/generics.rs b/macros/src/types/generics.rs index 074a3fb..5cd01d1 100644 --- a/macros/src/types/generics.rs +++ b/macros/src/types/generics.rs @@ -1,10 +1,11 @@ use proc_macro2::TokenStream; use quote::quote; use syn::{GenericArgument, GenericParam, Generics, PathArguments, Type}; +use crate::deps::Dependencies; pub fn format_type( ty: &Type, - dependencies: &mut Vec, + dependencies: &mut Dependencies, generics: &Generics, ) -> TokenStream { // If the type matches one of the generic parameters, just pass the identifier: @@ -28,13 +29,7 @@ pub fn format_type( return quote!(#generic_ident.to_owned()); } - dependencies.push(quote! { - if <#ty as ts_rs::TS>::transparent() { - dependencies.append(&mut <#ty as ts_rs::TS>::dependencies()); - } else { - dependencies.push((std::any::TypeId::of::<#ty>(), <#ty as ts_rs::TS>::name())); - } - }); + dependencies.push_or_append_from(ty); match extract_type_args(ty) { None => quote!(<#ty as ts_rs::TS>::name()), diff --git a/macros/src/types/mod.rs b/macros/src/types/mod.rs index cfea6a4..f895087 100644 --- a/macros/src/types/mod.rs +++ b/macros/src/types/mod.rs @@ -8,6 +8,7 @@ use crate::{ utils::to_ts_ident, DerivedTS, }; +use crate::deps::Dependencies; mod generics; mod named; @@ -35,8 +36,8 @@ fn type_def( }, Fields::Unnamed(unnamed) => match unnamed.unnamed.len() { 0 => unit::unit(name, rename_all), - 1 => newtype::newtype(name, rename_all, unnamed), - _ => tuple::tuple(name, rename_all, unnamed), + 1 => newtype::newtype(name, rename_all, unnamed, generics), + _ => tuple::tuple(name, rename_all, unnamed, generics), }, Fields::Unit => unit::unit(name, rename_all), } @@ -51,7 +52,7 @@ pub(crate) fn r#enum(s: &ItemEnum) -> Result { }; let mut formatted_variants = vec![]; - let mut dependencies = vec![]; + let mut dependencies = Dependencies::default(); for variant in &s.variants { format_variant( &mut formatted_variants, @@ -65,18 +66,14 @@ pub(crate) fn r#enum(s: &ItemEnum) -> Result { inline: quote!(vec![#(#formatted_variants),*].join(" | ")), decl: quote!(format!("type {} = {};", #name, Self::inline(0))), inline_flattened: None, - dependencies: quote! { - let mut dependencies = vec![]; - #( #dependencies )* - dependencies - }, + dependencies, name, }) } fn format_variant( formatted_variants: &mut Vec, - dependencies: &mut Vec, + dependencies: &mut Dependencies, enum_attr: &EnumAttr, variant: &Variant, ) -> Result<()> { @@ -144,8 +141,7 @@ fn format_variant( } Fields::Unit => quote!(format!("{{ {}: \"{}\" }}", #tag, #name)), _ => { - dependencies - .push(quote!(dependencies.append(&mut #variant_dependencies);)); + dependencies.append(variant_dependencies); quote!(format!("{{ {}: \"{}\" }} & {}", #tag, #name, #inline_type)) } }, diff --git a/macros/src/types/named.rs b/macros/src/types/named.rs index 76cd321..dd09419 100644 --- a/macros/src/types/named.rs +++ b/macros/src/types/named.rs @@ -10,6 +10,7 @@ use crate::{ utils::to_ts_ident, DerivedTS, }; +use crate::deps::Dependencies; pub(crate) fn named( name: &str, @@ -18,7 +19,7 @@ pub(crate) fn named( generics: &Generics, ) -> Result { let mut formatted_fields = vec![]; - let mut dependencies = vec![]; + let mut dependencies = Dependencies::default(); for field in &fields.named { format_field( &mut formatted_fields, @@ -56,18 +57,14 @@ pub(crate) fn named( decl: quote!(format!("interface {}{} {}", #name, #generic_args, Self::inline(0))), inline_flattened: Some(fields), name: name.to_owned(), - dependencies: quote! { - let mut dependencies = vec![]; - #( #dependencies )* - dependencies - }, + dependencies }) } // build an expresion which expands to a string, representing a single field of a struct. fn format_field( formatted_fields: &mut Vec, - dependencies: &mut Vec, + dependencies: &mut Dependencies, field: &Field, rename_all: &Option, generics: &Generics, @@ -99,14 +96,13 @@ fn format_field( } formatted_fields.push(quote!(<#ty as ts_rs::TS>::inline_flattened(indent))); - dependencies.push(quote!(dependencies.append(&mut <#ty as ts_rs::TS>::dependencies());)); + dependencies.append_from(ty); return Ok(()); } let formatted_ty = type_override.map(|t| quote!(#t)).unwrap_or_else(|| { if inline { - dependencies - .push(quote!(dependencies.append(&mut <#ty as ts_rs::TS>::dependencies());)); + dependencies.append_from(ty); quote!(<#ty as ts_rs::TS>::inline(indent + 1)) } else { format_type(ty, dependencies, generics) diff --git a/macros/src/types/newtype.rs b/macros/src/types/newtype.rs index 41da56a..e1a757e 100644 --- a/macros/src/types/newtype.rs +++ b/macros/src/types/newtype.rs @@ -1,8 +1,10 @@ use quote::quote; -use syn::{FieldsUnnamed, Result}; +use syn::{FieldsUnnamed, Generics, Result}; use crate::{ attr::{FieldAttr, Inflection}, + deps::Dependencies, + types::generics::format_type, DerivedTS, }; @@ -10,6 +12,7 @@ pub(crate) fn newtype( name: &str, rename_all: &Option, fields: &FieldsUnnamed, + generics: &Generics, ) -> Result { if rename_all.is_some() { syn_err!("`rename_all` is not applicable to newtype structs"); @@ -33,27 +36,23 @@ pub(crate) fn newtype( }; let inner_ty = &inner.ty; + let mut dependencies = Dependencies::default(); + match (inline, &type_override) { + (_, Some(_)) => (), + (true, _) => dependencies.append_from(inner_ty), + (false, _) => dependencies.push_or_append_from(inner_ty), + }; let inline_def = match &type_override { Some(o) => quote!(#o), None if inline => quote!(<#inner_ty as ts_rs::TS>::inline(0)), - None => quote!(<#inner_ty as ts_rs::TS>::name()), + None => format_type(inner_ty, &mut dependencies, generics), }; + Ok(DerivedTS { decl: quote!(format!("type {} = {};", #name, #inline_def)), inline: inline_def, inline_flattened: None, name: name.to_owned(), - dependencies: match (inline, &type_override) { - (_, Some(_)) => quote!(vec![]), - (true, _) => quote! { - <#inner_ty as ts_rs::TS>::dependencies() - }, - (false, _) => quote! { - match <#inner_ty as ts_rs::TS>::transparent() { - true => <#inner_ty as ts_rs::TS>::dependencies(), - false => vec![(std::any::TypeId::of::<#inner_ty>(), <#inner_ty as ts_rs::TS>::name())] - } - }, - }, + dependencies, }) } diff --git a/macros/src/types/tuple.rs b/macros/src/types/tuple.rs index 08c3be2..7019ba1 100644 --- a/macros/src/types/tuple.rs +++ b/macros/src/types/tuple.rs @@ -1,25 +1,28 @@ use proc_macro2::TokenStream; use quote::quote; -use syn::{Field, FieldsUnnamed, Result}; +use syn::{Field, FieldsUnnamed, Generics, Result}; use crate::{ attr::{FieldAttr, Inflection}, + deps::Dependencies, DerivedTS, }; +use crate::types::generics::format_type; pub(crate) fn tuple( name: &str, rename_all: &Option, fields: &FieldsUnnamed, + generics: &Generics, ) -> Result { if rename_all.is_some() { syn_err!("`rename_all` is not applicable to tuple structs"); } let mut formatted_fields = Vec::new(); - let mut dependencies = Vec::new(); + let mut dependencies = Dependencies::default(); for field in &fields.unnamed { - format_field(&mut formatted_fields, &mut dependencies, field)?; + format_field(&mut formatted_fields, &mut dependencies, field, generics)?; } Ok(DerivedTS { @@ -38,18 +41,15 @@ pub(crate) fn tuple( }, inline_flattened: None, name: name.to_owned(), - dependencies: quote! { - let mut dependencies = vec![]; - #( #dependencies )* - dependencies - }, + dependencies, }) } fn format_field( formatted_fields: &mut Vec, - dependencies: &mut Vec, + dependencies: &mut Dependencies, field: &Field, + generics: &Generics, ) -> Result<()> { let ty = &field.ty; let FieldAttr { @@ -77,22 +77,18 @@ fn format_field( formatted_fields.push(match &type_override { Some(o) => quote!(#o.to_owned()), None if inline => quote!(<#ty as ts_rs::TS>::inline(0)), - None => quote!(<#ty as ts_rs::TS>::name()), + None => format_type(ty, dependencies, generics), }); - dependencies.push(match (inline, &type_override) { - (_, Some(_)) => quote!(), - (false, _) => quote! { - if <#ty as ts_rs::TS>::transparent() { - dependencies.append(&mut <#ty as ts_rs::TS>::dependencies()); - } else { - dependencies.push((std::any::TypeId::of::<#ty>(), <#ty as ts_rs::TS>::name())); - } - }, - (true, _) => quote! { - dependencies.append(&mut (<#ty as ts_rs::TS>::dependencies())); - }, - }); + match (inline, &type_override) { + (_, Some(_)) => (), + (false, _) => { + dependencies.push_or_append_from(ty); + } + (true, _) => { + dependencies.append_from(ty); + } + }; Ok(()) } diff --git a/macros/src/types/unit.rs b/macros/src/types/unit.rs index c3a115b..3e42b96 100644 --- a/macros/src/types/unit.rs +++ b/macros/src/types/unit.rs @@ -2,6 +2,7 @@ use quote::quote; use syn::Result; use crate::{attr::Inflection, DerivedTS}; +use crate::deps::Dependencies; pub(crate) fn unit(name: &str, rename_all: &Option) -> Result { if rename_all.is_some() { @@ -13,6 +14,6 @@ pub(crate) fn unit(name: &str, rename_all: &Option) -> Result TS for Vec { "Array".to_owned() } + fn name_with_type_args(args: Vec) -> String { + assert_eq!(args.len(), 1); + format!("Array<{}>", args[0]) + } + fn inline(indent: usize) -> String { format!("Array<{}>", T::inline(indent)) } diff --git a/ts-rs/tests/generic_fields.rs b/ts-rs/tests/generic_fields.rs new file mode 100644 index 0000000..bc10925 --- /dev/null +++ b/ts-rs/tests/generic_fields.rs @@ -0,0 +1,70 @@ +#![allow(dead_code)] +use ts_rs::TS; + +#[test] +fn newtype() { + #[derive(TS)] + struct Newtype(Vec); + assert_eq!(Newtype::inline(0), "Array"); +} + +#[test] +fn newtype_nested() { + #[derive(TS)] + struct Newtype(Vec>); + assert_eq!(Newtype::inline(0), "Array>"); +} + +#[test] +fn alias() { + type Alias = Vec; + assert_eq!(Alias::inline(0), "Array"); +} + +#[test] +fn alias_nested() { + type Alias = Vec>; + assert_eq!(Alias::inline(0), "Array>"); +} + +#[test] +fn named() { + #[derive(TS)] + struct Struct { + a: Vec, + } + assert_eq!( + Struct::inline(0), + "{ + a: Array, +}" + ); +} + +#[test] +fn named_nested() { + #[derive(TS)] + struct Struct { + a: Vec>, + } + assert_eq!( + Struct::inline(0), + "{ + a: Array>, +}" + ); +} + +#[test] +fn tuple() { + #[derive(TS)] + struct Tuple(Vec, Vec); + assert_eq!(Tuple::inline(0), "[Array, Array]"); +} + +#[test] +fn tuple_nested() { + #[derive(TS)] + struct Tuple(Vec>, Vec>); + assert_eq!(Tuple::inline(0), "[Array>, Array>]"); +}