diff --git a/example/src/lib.rs b/example/src/lib.rs index 4650eb7..b34b7cc 100644 --- a/example/src/lib.rs +++ b/example/src/lib.rs @@ -51,6 +51,24 @@ struct Series { points: Vec>, } +#[derive(Serialize, TS)] +#[serde(tag = "kind", content = "d")] +enum SimpleEnum { + A, + B, +} + +#[derive(Serialize, TS)] +#[serde(tag = "kind", content = "data")] +enum ComplexEnum { + A, + B { foo: String, bar: f64 }, + W(SimpleEnum), + F { nested: SimpleEnum }, + T(i32, SimpleEnum), + V(Vec), +} + // this will export [Role] to `role.ts` and [User] to `user.ts` when running `cargo test`. // `export!` will also take care of including imports in typescript files. export! { @@ -60,6 +78,8 @@ export! { Point<()> => "point.ts", Series => "series.ts", Vehicle => "vehicle.ts", + ComplexEnum => "complex_enum.ts", + SimpleEnum => "simple_enum.ts", // this exports an ambient declaration (`declare interface`) instead of an `export interface`. (declare) Gender => "gender.d.ts", } diff --git a/macros/src/types/generics.rs b/macros/src/types/generics.rs new file mode 100644 index 0000000..074a3fb --- /dev/null +++ b/macros/src/types/generics.rs @@ -0,0 +1,76 @@ +use proc_macro2::TokenStream; +use quote::quote; +use syn::{GenericArgument, GenericParam, Generics, PathArguments, Type}; + +pub fn format_type( + ty: &Type, + dependencies: &mut Vec, + generics: &Generics, +) -> TokenStream { + // If the type matches one of the generic parameters, just pass the identifier: + if let Some(generic_ident) = generics + .params + .iter() + .filter_map(|param| match param { + GenericParam::Type(type_param) => Some(type_param), + _ => None, + }) + .find(|type_param| { + matches!( + ty, + Type::Path(type_path) + if type_path.qself.is_none() + && type_path.path.is_ident(&type_param.ident) + ) + }) + .map(|type_param| type_param.ident.to_string()) + { + 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())); + } + }); + + match extract_type_args(ty) { + None => quote!(<#ty as ts_rs::TS>::name()), + Some(type_args) => { + let args = type_args + .iter() + .map(|ty| format_type(ty, dependencies, generics)) + .collect::>(); + let args = quote!(vec![#(#args),*]); + quote!(<#ty as ts_rs::TS>::name_with_type_args(#args)) + } + } +} + +fn extract_type_args(ty: &Type) -> Option> { + let last_segment = match ty { + Type::Path(type_path) => type_path.path.segments.last(), + _ => None, + }?; + + let segment_arguments = match &last_segment.arguments { + PathArguments::AngleBracketed(generic_arguments) => Some(generic_arguments), + _ => None, + }?; + + let type_args: Vec<_> = segment_arguments + .args + .iter() + .filter_map(|arg| match arg { + GenericArgument::Type(ty) => Some(ty), + _ => None, + }) + .collect(); + if type_args.is_empty() { + return None; + } + + Some(type_args) +} diff --git a/macros/src/types/mod.rs b/macros/src/types/mod.rs index e01359a..1ac07a5 100644 --- a/macros/src/types/mod.rs +++ b/macros/src/types/mod.rs @@ -3,8 +3,10 @@ use quote::quote; use syn::{Fields, Generics, ItemEnum, ItemStruct, Result, Variant}; use crate::attr::{EnumAttr, FieldAttr, Inflection, StructAttr}; +use crate::types::generics::format_type; use crate::DerivedTS; +mod generics; mod named; mod newtype; mod tuple; @@ -100,18 +102,28 @@ fn format_variant( _ => {} }; - let derived_type = type_def(&name, &None, &variant.fields, &Generics::default())?; - let inline_type = derived_type.inline; - let derived_dependencies = derived_type.dependencies; + let generics = Generics::default(); + let variant_type = type_def(&name, &None, &variant.fields, &generics)?; + let variant_dependencies = variant_type.dependencies; + let inline_type = variant_type.inline; formatted_variants.push(match &enum_attr.untag { true => quote!(#inline_type), false => match &enum_attr.tag { Some(tag) => match &enum_attr.content { - Some(content) => { - quote!(format!("{{{}: \"{}\", {}: {}}}", #tag, #name, #content, #inline_type)) - } - None => match derived_type.inline_flattened { + Some(content) => match &variant.fields { + Fields::Unnamed(unnamed) if unnamed.unnamed.len() == 1 => { + let formatted_type = format_type(&unnamed.unnamed[0].ty, dependencies, &generics); + quote!( + format!("{{{}: \"{}\", {}: {}}}", #tag, #name, #content, #formatted_type) + ) + } + Fields::Unit => quote!(format!("{{{}: \"{}\"}}", #tag, #name)), + _ => quote!( + format!("{{{}: \"{}\", {}: {}}}", #tag, #name, #content, #inline_type) + ), + }, + None => match variant_type.inline_flattened { Some(inline_flattened) => quote! { format!( "{{\n{}{}: \"{}\",\n{}\n}}", @@ -122,7 +134,7 @@ fn format_variant( ) }, None => { - dependencies.push(quote!(dependencies.append(&mut #derived_dependencies);)); + dependencies.push(quote!(dependencies.append(&mut #variant_dependencies);)); quote! { format!( "\n{}{{ {}: \"{}\" }} & {}", diff --git a/macros/src/types/named.rs b/macros/src/types/named.rs index 2ed1d3f..5372c9d 100644 --- a/macros/src/types/named.rs +++ b/macros/src/types/named.rs @@ -5,6 +5,7 @@ use syn::{ }; use crate::attr::{FieldAttr, Inflection}; +use crate::types::generics::format_type; use crate::DerivedTS; pub(crate) fn named( @@ -143,72 +144,3 @@ fn extract_option_argument(ty: &Type) -> Result<&Type> { _ => syn_err!("`optional` can only be used on an Option type"), } } - -fn extract_type_args(ty: &Type) -> Option> { - let last_segment = match ty { - Type::Path(type_path) => type_path.path.segments.last(), - _ => None, - }?; - - let segment_arguments = match &last_segment.arguments { - PathArguments::AngleBracketed(generic_arguments) => Some(generic_arguments), - _ => None, - }?; - - let type_args: Vec<_> = segment_arguments - .args - .iter() - .filter_map(|arg| match arg { - GenericArgument::Type(ty) => Some(ty), - _ => None, - }) - .collect(); - if type_args.is_empty() { - return None; - } - - Some(type_args) -} - -fn format_type(ty: &Type, dependencies: &mut Vec, generics: &Generics) -> TokenStream { - // If the type matches one of the generic parameters, just pass the identifier: - if let Some(generic_ident) = generics - .params - .iter() - .filter_map(|param| match param { - GenericParam::Type(type_param) => Some(type_param), - _ => None, - }) - .find(|type_param| { - matches!( - ty, - Type::Path(type_path) - if type_path.qself.is_none() - && type_path.path.is_ident(&type_param.ident) - ) - }) - .map(|type_param| type_param.ident.to_string()) - { - 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())); - } - }); - - match extract_type_args(ty) { - None => quote!(<#ty as ts_rs::TS>::name()), - Some(type_args) => { - let args = type_args - .iter() - .map(|ty| format_type(ty, dependencies, generics)) - .collect::>(); - let args = quote!(vec![#(#args),*]); - quote!(<#ty as ts_rs::TS>::name_with_type_args(#args)) - } - } -} diff --git a/ts-rs/tests/union_serde.rs b/ts-rs/tests/union_serde.rs index 31f5981..baf3ac9 100644 --- a/ts-rs/tests/union_serde.rs +++ b/ts-rs/tests/union_serde.rs @@ -31,11 +31,11 @@ enum Untagged { fn test_serde_enum() { assert_eq!( SimpleEnum::decl(), - r#"type SimpleEnum = {kind: "A", d: null} | {kind: "B", d: null};"# + r#"type SimpleEnum = {kind: "A"} | {kind: "B"};"# ); assert_eq!( ComplexEnum::decl(), - r#"type ComplexEnum = {kind: "A", data: null} | {kind: "B", data: { + r#"type ComplexEnum = {kind: "A"} | {kind: "B", data: { foo: string, bar: number, }} | {kind: "W", data: SimpleEnum} | {kind: "F", data: {