mirror of
https://github.com/xazukx/ts-rs.git
synced 2026-11-19 22:40:25 +00:00
Allow arbitrary expressions in top-level #[ts(rename)] (#398)
This commit is contained in:
+5
-1
@@ -1,13 +1,17 @@
|
||||
# master
|
||||
### Breaking
|
||||
- Changed return type of `TS::output_path()` from `Option<&'static Path>` to `Option<PathBuf>`.
|
||||
This will only break your code if you manually implement `TS` or directly interact with the `TS` trait.
|
||||
- Added `OptionInnerType` associated type to the `TS` trait. If you manually implement `TS`, you must set this associated type to `Self` in all of your implementations.
|
||||
- Raised MSRV to `1.78.0` due to use of `#[diagnostic::on_unimplemented]` and `let ... else { ... }`
|
||||
|
||||
### Features
|
||||
- The `#[ts(rename)]` attribute on structs, enums and variants now accepts any expression.
|
||||
This makes it possible to, for example, rename a struct to the name of a module it is contained in using `#[ts(rename = module_path!().rsplit_once("::").unwrap().1)]`
|
||||
- Added `#[ts(optional_fields)]` and `#[ts(optional_fields = nullable)]` attribute to structs, this attribute is equivalent to using the corresponding `#[ts(optional)]` or `#[ts(optional = nullable)]` on every field of the struct. ([#366](https://github.com/Aleph-Alpha/ts-rs/pull/366))
|
||||
|
||||
### Fixes
|
||||
- Fix `#[ts(optional)]` error when using a type alias for `Option` or fully qqualifying it as `core::option::Option` ([#366](https://github.com/Aleph-Alpha/ts-rs/pull/366))
|
||||
- Fix `#[ts(optional)]` error when using a type alias for `Option` or fully qualifying it as `core::option::Option` ([#366](https://github.com/Aleph-Alpha/ts-rs/pull/366))
|
||||
- Fix missing import statements when using `#[ts(as = "...")]` at the top level of a struct/enum ([#385](https://github.com/Aleph-Alpha/ts-rs/pull/385))
|
||||
|
||||
# 10.1.0
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use syn::{parse_quote, Attribute, Ident, ItemEnum, Path, Result, Type, WherePredicate};
|
||||
use syn::{parse_quote, Attribute, Expr, Ident, ItemEnum, Path, Result, Type, WherePredicate};
|
||||
|
||||
use super::{parse_assign_from_str, parse_bound, Attr, ContainerAttr, Serde};
|
||||
use super::{parse_assign_expr, parse_assign_from_str, parse_bound, Attr, ContainerAttr, Serde};
|
||||
use crate::{
|
||||
attr::{parse_assign_inflection, parse_assign_str, parse_concrete, Inflection},
|
||||
utils::{parse_attrs, parse_docs},
|
||||
@@ -15,7 +15,7 @@ pub struct EnumAttr {
|
||||
pub type_override: Option<String>,
|
||||
pub rename_all: Option<Inflection>,
|
||||
pub rename_all_fields: Option<Inflection>,
|
||||
pub rename: Option<String>,
|
||||
pub rename: Option<Expr>,
|
||||
pub export_to: Option<String>,
|
||||
pub export: bool,
|
||||
pub docs: String,
|
||||
@@ -209,7 +209,7 @@ impl_parse! {
|
||||
"crate" => out.crate_rename = Some(parse_assign_from_str(input)?),
|
||||
"as" => out.type_as = Some(parse_assign_from_str(input)?),
|
||||
"type" => out.type_override = Some(parse_assign_str(input)?),
|
||||
"rename" => out.rename = Some(parse_assign_str(input)?),
|
||||
"rename" => out.rename = Some(parse_assign_expr(input)?),
|
||||
"rename_all" => out.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"rename_all_fields" => out.rename_all_fields = Some(parse_assign_inflection(input)?),
|
||||
"export_to" => out.export_to = Some(parse_assign_str(input)?),
|
||||
@@ -224,7 +224,7 @@ impl_parse! {
|
||||
|
||||
impl_parse! {
|
||||
Serde<EnumAttr>(input, out) {
|
||||
"rename" => out.0.rename = Some(parse_assign_str(input)?),
|
||||
"rename" => out.0.rename = Some(parse_assign_expr(input)?),
|
||||
"rename_all" => out.0.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"rename_all_fields" => out.0.rename_all_fields = Some(parse_assign_inflection(input)?),
|
||||
"tag" => out.0.tag = Some(parse_assign_str(input)?),
|
||||
|
||||
@@ -2,13 +2,13 @@ use std::collections::HashMap;
|
||||
|
||||
pub use field::*;
|
||||
use proc_macro2::TokenTree;
|
||||
use quote::quote;
|
||||
pub use r#enum::*;
|
||||
pub use r#struct::*;
|
||||
use quote::quote;
|
||||
use syn::{
|
||||
parse::{Parse, ParseStream},
|
||||
punctuated::Punctuated,
|
||||
Error, Ident, Lit, Path, Result, Token, WherePredicate,
|
||||
Error, Expr, Ident, Lit, Path, Result, Token, WherePredicate,
|
||||
};
|
||||
pub use variant::*;
|
||||
|
||||
@@ -149,6 +149,11 @@ fn skip_until_next_comma(input: ParseStream) -> proc_macro2::TokenStream {
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn parse_assign_expr(input: ParseStream) -> Result<Expr> {
|
||||
input.parse::<Token![=]>()?;
|
||||
Expr::parse(input)
|
||||
}
|
||||
|
||||
fn parse_assign_str(input: ParseStream) -> Result<String> {
|
||||
input.parse::<Token![=]>()?;
|
||||
match Lit::parse(input)? {
|
||||
|
||||
+188
-188
@@ -1,188 +1,188 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use syn::{parse_quote, Attribute, Fields, Ident, Path, Result, Type, WherePredicate};
|
||||
|
||||
use super::{
|
||||
parse_assign_from_str, parse_assign_inflection, parse_bound, parse_concrete, parse_optional,
|
||||
Attr, ContainerAttr, Optional, Serde, Tagged,
|
||||
};
|
||||
use crate::{
|
||||
attr::{parse_assign_str, EnumAttr, Inflection, VariantAttr},
|
||||
utils::{parse_attrs, parse_docs},
|
||||
};
|
||||
|
||||
#[derive(Default, Clone)]
|
||||
pub struct StructAttr {
|
||||
crate_rename: Option<Path>,
|
||||
pub type_as: Option<Type>,
|
||||
pub type_override: Option<String>,
|
||||
pub rename_all: Option<Inflection>,
|
||||
pub rename: Option<String>,
|
||||
pub export_to: Option<String>,
|
||||
pub export: bool,
|
||||
pub tag: Option<String>,
|
||||
pub docs: String,
|
||||
pub concrete: HashMap<Ident, Type>,
|
||||
pub bound: Option<Vec<WherePredicate>>,
|
||||
pub optional_fields: Optional,
|
||||
}
|
||||
|
||||
impl StructAttr {
|
||||
pub fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
|
||||
let mut result = parse_attrs::<Self>(attrs)?;
|
||||
|
||||
if cfg!(feature = "serde-compat") {
|
||||
let serde_attr = crate::utils::parse_serde_attrs::<StructAttr>(attrs);
|
||||
result = result.merge(serde_attr.0);
|
||||
}
|
||||
|
||||
let docs = parse_docs(attrs)?;
|
||||
result.docs = docs;
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
pub fn from_variant(
|
||||
enum_attr: &EnumAttr,
|
||||
variant_attr: &VariantAttr,
|
||||
variant_fields: &Fields,
|
||||
) -> Self {
|
||||
Self {
|
||||
crate_rename: Some(enum_attr.crate_rename()),
|
||||
rename: variant_attr.rename.clone(),
|
||||
rename_all: variant_attr.rename_all.or(match variant_fields {
|
||||
Fields::Named(_) => enum_attr.rename_all_fields,
|
||||
Fields::Unnamed(_) | Fields::Unit => None,
|
||||
}),
|
||||
tag: match variant_fields {
|
||||
Fields::Named(_) => match enum_attr
|
||||
.tagged()
|
||||
.expect("The variant attribute is known to be valid at this point")
|
||||
{
|
||||
Tagged::Internally { tag } => Some(tag.to_owned()),
|
||||
_ => None,
|
||||
},
|
||||
_ => None,
|
||||
},
|
||||
|
||||
// inline and skip are not supported on StructAttr
|
||||
..Self::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Attr for StructAttr {
|
||||
type Item = Fields;
|
||||
|
||||
fn merge(self, other: Self) -> Self {
|
||||
Self {
|
||||
crate_rename: self.crate_rename.or(other.crate_rename),
|
||||
type_as: self.type_as.or(other.type_as),
|
||||
type_override: self.type_override.or(other.type_override),
|
||||
rename: self.rename.or(other.rename),
|
||||
rename_all: self.rename_all.or(other.rename_all),
|
||||
export_to: self.export_to.or(other.export_to),
|
||||
export: self.export || other.export,
|
||||
tag: self.tag.or(other.tag),
|
||||
docs: other.docs,
|
||||
concrete: self.concrete.into_iter().chain(other.concrete).collect(),
|
||||
bound: match (self.bound, other.bound) {
|
||||
(Some(a), Some(b)) => Some(a.into_iter().chain(b).collect()),
|
||||
(Some(bound), None) | (None, Some(bound)) => Some(bound),
|
||||
(None, None) => None,
|
||||
},
|
||||
optional_fields: self.optional_fields.or(other.optional_fields),
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_validity(&self, item: &Self::Item) -> Result<()> {
|
||||
if self.type_override.is_some() {
|
||||
if self.type_as.is_some() {
|
||||
syn_err!("`as` is not compatible with `type`");
|
||||
}
|
||||
|
||||
if self.rename_all.is_some() {
|
||||
syn_err!("`rename_all` is not compatible with `type`");
|
||||
}
|
||||
|
||||
if self.tag.is_some() {
|
||||
syn_err!("`tag` is not compatible with `type`");
|
||||
}
|
||||
|
||||
if let Optional::Optional { .. } = self.optional_fields {
|
||||
syn_err!("`optional_fields` is not compatible with `type`");
|
||||
}
|
||||
}
|
||||
|
||||
if self.type_as.is_some() {
|
||||
if self.tag.is_some() {
|
||||
syn_err!("`tag` is not compatible with `as`");
|
||||
}
|
||||
|
||||
if self.rename_all.is_some() {
|
||||
syn_err!("`rename_all` is not compatible with `as`");
|
||||
}
|
||||
|
||||
if let Optional::Optional { .. } = self.optional_fields {
|
||||
syn_err!("`optional_fields` is not compatible with `as`");
|
||||
}
|
||||
}
|
||||
|
||||
if !matches!(item, Fields::Named(_)) {
|
||||
if self.tag.is_some() {
|
||||
syn_err!("`tag` cannot be used with unit or tuple structs");
|
||||
}
|
||||
|
||||
if self.rename_all.is_some() {
|
||||
syn_err!("`rename_all` cannot be used with unit or tuple structs");
|
||||
}
|
||||
|
||||
if let Optional::Optional { .. } = self.optional_fields {
|
||||
syn_err!("`optional_fields` cannot be used with unit or tuple structs");
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ContainerAttr for StructAttr {
|
||||
fn crate_rename(&self) -> Path {
|
||||
self.crate_rename
|
||||
.clone()
|
||||
.unwrap_or_else(|| parse_quote!(::ts_rs))
|
||||
}
|
||||
}
|
||||
|
||||
impl_parse! {
|
||||
StructAttr(input, out) {
|
||||
"crate" => out.crate_rename = Some(parse_assign_from_str(input)?),
|
||||
"as" => out.type_as = Some(parse_assign_from_str(input)?),
|
||||
"type" => out.type_override = Some(parse_assign_str(input)?),
|
||||
"rename" => out.rename = Some(parse_assign_str(input)?),
|
||||
"rename_all" => out.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"tag" => out.tag = Some(parse_assign_str(input)?),
|
||||
"export" => out.export = true,
|
||||
"export_to" => out.export_to = Some(parse_assign_str(input)?),
|
||||
"concrete" => out.concrete = parse_concrete(input)?,
|
||||
"bound" => out.bound = Some(parse_bound(input)?),
|
||||
"optional_fields" => out.optional_fields = parse_optional(input)?,
|
||||
}
|
||||
}
|
||||
|
||||
impl_parse! {
|
||||
Serde<StructAttr>(input, out) {
|
||||
"rename" => out.0.rename = Some(parse_assign_str(input)?),
|
||||
"rename_all" => out.0.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"tag" => out.0.tag = Some(parse_assign_str(input)?),
|
||||
"bound" => out.0.bound = Some(parse_bound(input)?),
|
||||
// parse #[serde(default)] to not emit a warning
|
||||
"deny_unknown_fields" | "default" => {
|
||||
use syn::Token;
|
||||
if input.peek(Token![=]) {
|
||||
input.parse::<Token![=]>()?;
|
||||
parse_assign_str(input)?;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
use std::collections::HashMap;
|
||||
|
||||
use syn::{parse_quote, Attribute, Expr, Fields, Ident, Path, Result, Type, WherePredicate};
|
||||
|
||||
use super::{
|
||||
parse_assign_expr, parse_assign_from_str, parse_assign_inflection, parse_bound, parse_concrete,
|
||||
parse_optional, Attr, ContainerAttr, Optional, Serde, Tagged,
|
||||
};
|
||||
use crate::{
|
||||
attr::{parse_assign_str, EnumAttr, Inflection, VariantAttr},
|
||||
utils::{parse_attrs, parse_docs},
|
||||
};
|
||||
|
||||
#[derive(Default, Clone)]
|
||||
pub struct StructAttr {
|
||||
crate_rename: Option<Path>,
|
||||
pub type_as: Option<Type>,
|
||||
pub type_override: Option<String>,
|
||||
pub rename_all: Option<Inflection>,
|
||||
pub rename: Option<Expr>,
|
||||
pub export_to: Option<String>,
|
||||
pub export: bool,
|
||||
pub tag: Option<String>,
|
||||
pub docs: String,
|
||||
pub concrete: HashMap<Ident, Type>,
|
||||
pub bound: Option<Vec<WherePredicate>>,
|
||||
pub optional_fields: Optional,
|
||||
}
|
||||
|
||||
impl StructAttr {
|
||||
pub fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
|
||||
let mut result = parse_attrs::<Self>(attrs)?;
|
||||
|
||||
if cfg!(feature = "serde-compat") {
|
||||
let serde_attr = crate::utils::parse_serde_attrs::<StructAttr>(attrs);
|
||||
result = result.merge(serde_attr.0);
|
||||
}
|
||||
|
||||
let docs = parse_docs(attrs)?;
|
||||
result.docs = docs;
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
pub fn from_variant(
|
||||
enum_attr: &EnumAttr,
|
||||
variant_attr: &VariantAttr,
|
||||
variant_fields: &Fields,
|
||||
) -> Self {
|
||||
Self {
|
||||
crate_rename: Some(enum_attr.crate_rename()),
|
||||
rename: variant_attr.rename.clone(),
|
||||
rename_all: variant_attr.rename_all.or(match variant_fields {
|
||||
Fields::Named(_) => enum_attr.rename_all_fields,
|
||||
Fields::Unnamed(_) | Fields::Unit => None,
|
||||
}),
|
||||
tag: match variant_fields {
|
||||
Fields::Named(_) => match enum_attr
|
||||
.tagged()
|
||||
.expect("The variant attribute is known to be valid at this point")
|
||||
{
|
||||
Tagged::Internally { tag } => Some(tag.to_owned()),
|
||||
_ => None,
|
||||
},
|
||||
_ => None,
|
||||
},
|
||||
|
||||
// inline and skip are not supported on StructAttr
|
||||
..Self::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Attr for StructAttr {
|
||||
type Item = Fields;
|
||||
|
||||
fn merge(self, other: Self) -> Self {
|
||||
Self {
|
||||
crate_rename: self.crate_rename.or(other.crate_rename),
|
||||
type_as: self.type_as.or(other.type_as),
|
||||
type_override: self.type_override.or(other.type_override),
|
||||
rename: self.rename.or(other.rename),
|
||||
rename_all: self.rename_all.or(other.rename_all),
|
||||
export_to: self.export_to.or(other.export_to),
|
||||
export: self.export || other.export,
|
||||
tag: self.tag.or(other.tag),
|
||||
docs: other.docs,
|
||||
concrete: self.concrete.into_iter().chain(other.concrete).collect(),
|
||||
bound: match (self.bound, other.bound) {
|
||||
(Some(a), Some(b)) => Some(a.into_iter().chain(b).collect()),
|
||||
(Some(bound), None) | (None, Some(bound)) => Some(bound),
|
||||
(None, None) => None,
|
||||
},
|
||||
optional_fields: self.optional_fields.or(other.optional_fields),
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_validity(&self, item: &Self::Item) -> Result<()> {
|
||||
if self.type_override.is_some() {
|
||||
if self.type_as.is_some() {
|
||||
syn_err!("`as` is not compatible with `type`");
|
||||
}
|
||||
|
||||
if self.rename_all.is_some() {
|
||||
syn_err!("`rename_all` is not compatible with `type`");
|
||||
}
|
||||
|
||||
if self.tag.is_some() {
|
||||
syn_err!("`tag` is not compatible with `type`");
|
||||
}
|
||||
|
||||
if let Optional::Optional { .. } = self.optional_fields {
|
||||
syn_err!("`optional_fields` is not compatible with `type`");
|
||||
}
|
||||
}
|
||||
|
||||
if self.type_as.is_some() {
|
||||
if self.tag.is_some() {
|
||||
syn_err!("`tag` is not compatible with `as`");
|
||||
}
|
||||
|
||||
if self.rename_all.is_some() {
|
||||
syn_err!("`rename_all` is not compatible with `as`");
|
||||
}
|
||||
|
||||
if let Optional::Optional { .. } = self.optional_fields {
|
||||
syn_err!("`optional_fields` is not compatible with `as`");
|
||||
}
|
||||
}
|
||||
|
||||
if !matches!(item, Fields::Named(_)) {
|
||||
if self.tag.is_some() {
|
||||
syn_err!("`tag` cannot be used with unit or tuple structs");
|
||||
}
|
||||
|
||||
if self.rename_all.is_some() {
|
||||
syn_err!("`rename_all` cannot be used with unit or tuple structs");
|
||||
}
|
||||
|
||||
if let Optional::Optional { .. } = self.optional_fields {
|
||||
syn_err!("`optional_fields` cannot be used with unit or tuple structs");
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ContainerAttr for StructAttr {
|
||||
fn crate_rename(&self) -> Path {
|
||||
self.crate_rename
|
||||
.clone()
|
||||
.unwrap_or_else(|| parse_quote!(::ts_rs))
|
||||
}
|
||||
}
|
||||
|
||||
impl_parse! {
|
||||
StructAttr(input, out) {
|
||||
"crate" => out.crate_rename = Some(parse_assign_from_str(input)?),
|
||||
"as" => out.type_as = Some(parse_assign_from_str(input)?),
|
||||
"type" => out.type_override = Some(parse_assign_str(input)?),
|
||||
"rename" => out.rename = Some(parse_assign_expr(input)?),
|
||||
"rename_all" => out.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"tag" => out.tag = Some(parse_assign_str(input)?),
|
||||
"export" => out.export = true,
|
||||
"export_to" => out.export_to = Some(parse_assign_str(input)?),
|
||||
"concrete" => out.concrete = parse_concrete(input)?,
|
||||
"bound" => out.bound = Some(parse_bound(input)?),
|
||||
"optional_fields" => out.optional_fields = parse_optional(input)?,
|
||||
}
|
||||
}
|
||||
|
||||
impl_parse! {
|
||||
Serde<StructAttr>(input, out) {
|
||||
"rename" => out.0.rename = Some(parse_assign_expr(input)?),
|
||||
"rename_all" => out.0.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"tag" => out.0.tag = Some(parse_assign_str(input)?),
|
||||
"bound" => out.0.bound = Some(parse_bound(input)?),
|
||||
// parse #[serde(default)] to not emit a warning
|
||||
"deny_unknown_fields" | "default" => {
|
||||
use syn::Token;
|
||||
if input.peek(Token![=]) {
|
||||
input.parse::<Token![=]>()?;
|
||||
parse_assign_str(input)?;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use syn::{Attribute, Fields, Ident, Result, Type, Variant};
|
||||
use syn::{Attribute, Expr, Fields, Ident, Result, Type, Variant};
|
||||
|
||||
use super::{Attr, Serde};
|
||||
use super::{parse_assign_expr, Attr, Serde};
|
||||
use crate::{
|
||||
attr::{parse_assign_from_str, parse_assign_inflection, parse_assign_str, Inflection},
|
||||
utils::parse_attrs,
|
||||
@@ -10,7 +10,7 @@ use crate::{
|
||||
pub struct VariantAttr {
|
||||
pub type_as: Option<Type>,
|
||||
pub type_override: Option<String>,
|
||||
pub rename: Option<String>,
|
||||
pub rename: Option<Expr>,
|
||||
pub rename_all: Option<Inflection>,
|
||||
pub inline: bool,
|
||||
pub skip: bool,
|
||||
@@ -91,7 +91,7 @@ impl_parse! {
|
||||
VariantAttr(input, out) {
|
||||
"as" => out.type_as = Some(parse_assign_from_str(input)?),
|
||||
"type" => out.type_override = Some(parse_assign_str(input)?),
|
||||
"rename" => out.rename = Some(parse_assign_str(input)?),
|
||||
"rename" => out.rename = Some(parse_assign_expr(input)?),
|
||||
"rename_all" => out.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"inline" => out.inline = true,
|
||||
"skip" => out.skip = true,
|
||||
@@ -101,7 +101,7 @@ impl_parse! {
|
||||
|
||||
impl_parse! {
|
||||
Serde<VariantAttr>(input, out) {
|
||||
"rename" => out.0.rename = Some(parse_assign_str(input)?),
|
||||
"rename" => out.0.rename = Some(parse_assign_expr(input)?),
|
||||
"rename_all" => out.0.rename_all = Some(parse_assign_inflection(input)?),
|
||||
"skip" => out.0.skip = true,
|
||||
"untagged" => out.0.untagged = true,
|
||||
|
||||
+16
-12
@@ -6,9 +6,9 @@ use std::collections::{HashMap, HashSet};
|
||||
use proc_macro2::{Ident, TokenStream};
|
||||
use quote::{format_ident, quote};
|
||||
use syn::{
|
||||
parse_quote, spanned::Spanned, ConstParam, GenericParam, Generics, Item, LifetimeParam, Path,
|
||||
Result, Type, TypeArray, TypeParam, TypeParen, TypePath, TypeReference, TypeSlice, TypeTuple,
|
||||
WhereClause, WherePredicate,
|
||||
parse_quote, spanned::Spanned, ConstParam, Expr, GenericParam, Generics, Item, LifetimeParam,
|
||||
Path, Result, Type, TypeArray, TypeParam, TypeParen, TypePath, TypeReference, TypeSlice,
|
||||
TypeTuple, WhereClause, WherePredicate,
|
||||
};
|
||||
|
||||
use crate::{deps::Dependencies, utils::format_generics};
|
||||
@@ -21,7 +21,7 @@ mod types;
|
||||
|
||||
struct DerivedTS {
|
||||
crate_rename: Path,
|
||||
ts_name: String,
|
||||
ts_name: Expr,
|
||||
docs: String,
|
||||
inline: TokenStream,
|
||||
inline_flattened: Option<TokenStream>,
|
||||
@@ -40,17 +40,21 @@ impl DerivedTS {
|
||||
.then(|| self.generate_export_test(&rust_ty, &generics));
|
||||
|
||||
let output_path_fn = {
|
||||
let path = match self.export_to.as_deref() {
|
||||
let ts_name = &self.ts_name;
|
||||
// expression of type `String` containing the file path
|
||||
let path_string = match self.export_to.as_deref() {
|
||||
Some(dirname) if dirname.ends_with('/') => {
|
||||
format!("{}{}.ts", dirname, self.ts_name)
|
||||
quote![format!("{}{}.ts", #dirname, #ts_name)]
|
||||
}
|
||||
Some(filename) => quote![#filename.to_owned()],
|
||||
None => {
|
||||
quote![format!("{}.ts", #ts_name)]
|
||||
}
|
||||
Some(filename) => filename.to_owned(),
|
||||
None => format!("{}.ts", self.ts_name),
|
||||
};
|
||||
|
||||
quote! {
|
||||
fn output_path() -> Option<&'static std::path::Path> {
|
||||
Some(std::path::Path::new(#path))
|
||||
fn output_path() -> Option<std::path::PathBuf> {
|
||||
Some(std::path::PathBuf::from(#path_string))
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -83,7 +87,7 @@ impl DerivedTS {
|
||||
type OptionInnerType = Self;
|
||||
|
||||
fn ident() -> String {
|
||||
#ident.to_owned()
|
||||
(#ident).to_string()
|
||||
}
|
||||
|
||||
#docs
|
||||
@@ -122,7 +126,7 @@ impl DerivedTS {
|
||||
format!("{}<{}>", #name, vec![#(#generics_ts_names),*].join(", "))
|
||||
}
|
||||
} else {
|
||||
quote!(#name.to_owned())
|
||||
quote!((#name).to_string())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+30
-23
@@ -1,11 +1,12 @@
|
||||
use proc_macro2::TokenStream;
|
||||
use quote::quote;
|
||||
use syn::{Fields, ItemEnum, Variant};
|
||||
use syn::{ext::IdentExt, Expr, Fields, ItemEnum, Variant};
|
||||
|
||||
use crate::{
|
||||
attr::{Attr, EnumAttr, FieldAttr, StructAttr, Tagged, VariantAttr},
|
||||
deps::Dependencies,
|
||||
types::{self, type_as, type_override},
|
||||
utils::make_string_literal,
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
@@ -18,15 +19,15 @@ pub(crate) fn r#enum_def(s: &ItemEnum) -> syn::Result<DerivedTS> {
|
||||
|
||||
let name = match &enum_attr.rename {
|
||||
Some(existing) => existing.clone(),
|
||||
None => s.ident.to_string(),
|
||||
None => make_string_literal(&s.ident.unraw().to_string(), s.ident.span()),
|
||||
};
|
||||
|
||||
if let Some(attr_type_override) = &enum_attr.type_override {
|
||||
return type_override::type_override_enum(&enum_attr, &name, attr_type_override);
|
||||
return type_override::type_override_enum(&enum_attr, name, attr_type_override);
|
||||
}
|
||||
|
||||
if let Some(attr_type_as) = &enum_attr.type_as {
|
||||
return type_as::type_as_enum(&enum_attr, &name, attr_type_as);
|
||||
return type_as::type_as_enum(&enum_attr, name, attr_type_as);
|
||||
}
|
||||
|
||||
if s.variants.is_empty() {
|
||||
@@ -81,17 +82,22 @@ fn format_variant(
|
||||
}
|
||||
|
||||
let untagged_variant = variant_attr.untagged;
|
||||
let name = match (variant_attr.rename.clone(), &enum_attr.rename_all) {
|
||||
let ts_name = match (variant_attr.rename.clone(), &enum_attr.rename_all) {
|
||||
(Some(rn), _) => rn,
|
||||
(None, None) => variant.ident.to_string(),
|
||||
(None, Some(rn)) => rn.apply(&variant.ident.to_string()),
|
||||
(None, None) => {
|
||||
make_string_literal(&variant.ident.unraw().to_string(), variant.ident.span())
|
||||
}
|
||||
(None, Some(rn)) => make_string_literal(
|
||||
&rn.apply(&variant.ident.unraw().to_string()),
|
||||
variant.ident.span(),
|
||||
),
|
||||
};
|
||||
|
||||
let struct_attr = StructAttr::from_variant(enum_attr, &variant_attr, &variant.fields);
|
||||
let variant_type = types::type_def(
|
||||
&struct_attr,
|
||||
// In internally tagged enums, we can tag the struct
|
||||
&name,
|
||||
ts_name.clone(),
|
||||
&variant.fields,
|
||||
)?;
|
||||
|
||||
@@ -114,7 +120,7 @@ fn format_variant(
|
||||
let formatted = match (untagged_variant, enum_attr.tagged()?) {
|
||||
(true, _) | (_, Tagged::Untagged) => quote!(#parsed_ty),
|
||||
(false, Tagged::Externally) => match &variant.fields {
|
||||
Fields::Unit => quote!(format!("\"{}\"", #name)),
|
||||
Fields::Unit => quote!(format!("\"{}\"", #ts_name)),
|
||||
Fields::Unnamed(unnamed) if unnamed.unnamed.len() == 1 => {
|
||||
let field = &unnamed.unnamed[0];
|
||||
let field_attr = FieldAttr::from_attrs(&field.attrs)?;
|
||||
@@ -122,12 +128,12 @@ fn format_variant(
|
||||
field_attr.assert_validity(field)?;
|
||||
|
||||
if field_attr.skip {
|
||||
quote!(format!("\"{}\"", #name))
|
||||
quote!(format!("\"{}\"", #ts_name))
|
||||
} else {
|
||||
quote!(format!("{{ \"{}\": {} }}", #name, #parsed_ty))
|
||||
quote!(format!("{{ \"{}\": {} }}", #ts_name, #parsed_ty))
|
||||
}
|
||||
}
|
||||
_ => quote!(format!("{{ \"{}\": {} }}", #name, #parsed_ty)),
|
||||
_ => quote!(format!("{{ \"{}\": {} }}", #ts_name, #parsed_ty)),
|
||||
},
|
||||
(false, Tagged::Adjacently { tag, content }) => match &variant.fields {
|
||||
Fields::Unnamed(unnamed) if unnamed.unnamed.len() == 1 => {
|
||||
@@ -137,7 +143,7 @@ fn format_variant(
|
||||
field_attr.assert_validity(field)?;
|
||||
|
||||
if field_attr.skip {
|
||||
quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #name))
|
||||
quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #ts_name))
|
||||
} else {
|
||||
let ty = match field_attr.type_override {
|
||||
Some(type_override) => quote!(#type_override),
|
||||
@@ -146,12 +152,14 @@ fn format_variant(
|
||||
quote!(<#ty as #crate_rename::TS>::name())
|
||||
}
|
||||
};
|
||||
quote!(format!("{{ \"{}\": \"{}\", \"{}\": {} }}", #tag, #name, #content, #ty))
|
||||
quote!(
|
||||
format!("{{ \"{}\": \"{}\", \"{}\": {} }}", #tag, #ts_name, #content, #ty)
|
||||
)
|
||||
}
|
||||
}
|
||||
Fields::Unit => quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #name)),
|
||||
Fields::Unit => quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #ts_name)),
|
||||
_ => quote!(
|
||||
format!("{{ \"{}\": \"{}\", \"{}\": {} }}", #tag, #name, #content, #parsed_ty)
|
||||
format!("{{ \"{}\": \"{}\", \"{}\": {} }}", #tag, #ts_name, #content, #parsed_ty)
|
||||
),
|
||||
},
|
||||
(false, Tagged::Internally { tag }) => match variant_type.inline_flattened {
|
||||
@@ -166,7 +174,7 @@ fn format_variant(
|
||||
field_attr.assert_validity(field)?;
|
||||
|
||||
if field_attr.skip {
|
||||
quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #name))
|
||||
quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #ts_name))
|
||||
} else {
|
||||
let ty = match field_attr.type_override {
|
||||
Some(type_override) => quote! { #type_override },
|
||||
@@ -176,12 +184,12 @@ fn format_variant(
|
||||
}
|
||||
};
|
||||
|
||||
quote!(format!("{{ \"{}\": \"{}\" }} & {}", #tag, #name, #ty))
|
||||
quote!(format!("{{ \"{}\": \"{}\" }} & {}", #tag, #ts_name, #ty))
|
||||
}
|
||||
}
|
||||
Fields::Unit => quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #name)),
|
||||
Fields::Unit => quote!(format!("{{ \"{}\": \"{}\" }}", #tag, #ts_name)),
|
||||
_ => {
|
||||
quote!(format!("{{ \"{}\": \"{}\" }} & {}", #tag, #name, #parsed_ty))
|
||||
quote!(format!("{{ \"{}\": \"{}\" }} & {}", #tag, #ts_name, #parsed_ty))
|
||||
}
|
||||
},
|
||||
},
|
||||
@@ -192,8 +200,7 @@ fn format_variant(
|
||||
}
|
||||
|
||||
// bindings for an empty enum (`never` in TS)
|
||||
fn empty_enum(name: impl Into<String>, enum_attr: EnumAttr) -> DerivedTS {
|
||||
let name = name.into();
|
||||
fn empty_enum(ts_name: Expr, enum_attr: EnumAttr) -> DerivedTS {
|
||||
let crate_rename = enum_attr.crate_rename();
|
||||
DerivedTS {
|
||||
crate_rename: crate_rename.clone(),
|
||||
@@ -203,7 +210,7 @@ fn empty_enum(name: impl Into<String>, enum_attr: EnumAttr) -> DerivedTS {
|
||||
dependencies: Dependencies::new(crate_rename),
|
||||
export: enum_attr.export,
|
||||
export_to: enum_attr.export_to,
|
||||
ts_name: name,
|
||||
ts_name,
|
||||
concrete: enum_attr.concrete,
|
||||
bound: enum_attr.bound,
|
||||
}
|
||||
|
||||
+52
-50
@@ -1,50 +1,52 @@
|
||||
use syn::{Fields, ItemStruct, Result};
|
||||
|
||||
use crate::{
|
||||
attr::{Attr, StructAttr},
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
mod r#enum;
|
||||
mod named;
|
||||
mod newtype;
|
||||
mod tuple;
|
||||
mod type_as;
|
||||
mod type_override;
|
||||
mod unit;
|
||||
|
||||
pub(crate) use r#enum::r#enum_def;
|
||||
|
||||
pub(crate) fn struct_def(s: &ItemStruct) -> Result<DerivedTS> {
|
||||
let attr = StructAttr::from_attrs(&s.attrs)?;
|
||||
|
||||
type_def(&attr, &s.ident.to_string(), &s.fields)
|
||||
}
|
||||
|
||||
fn type_def(attr: &StructAttr, ident: &str, fields: &Fields) -> Result<DerivedTS> {
|
||||
attr.assert_validity(fields)?;
|
||||
|
||||
let name = attr
|
||||
.rename
|
||||
.clone()
|
||||
.unwrap_or_else(|| ident.trim_start_matches("r#").to_owned());
|
||||
if let Some(attr_type_override) = &attr.type_override {
|
||||
return type_override::type_override_struct(attr, &name, attr_type_override);
|
||||
}
|
||||
if let Some(attr_type_as) = &attr.type_as {
|
||||
return type_as::type_as_struct(attr, &name, attr_type_as);
|
||||
}
|
||||
|
||||
match fields {
|
||||
Fields::Named(named) => match named.named.len() {
|
||||
0 if attr.tag.is_none() => unit::empty_object(attr, &name),
|
||||
_ => named::named(attr, &name, named),
|
||||
},
|
||||
Fields::Unnamed(unnamed) => match unnamed.unnamed.len() {
|
||||
0 => unit::empty_array(attr, &name),
|
||||
1 => newtype::newtype(attr, &name, unnamed),
|
||||
_ => tuple::tuple(attr, &name, unnamed),
|
||||
},
|
||||
Fields::Unit => unit::null(attr, &name),
|
||||
}
|
||||
}
|
||||
use syn::{ext::IdentExt, Expr, Fields, ItemStruct, Result};
|
||||
|
||||
use crate::{
|
||||
attr::{Attr, StructAttr},
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
mod r#enum;
|
||||
mod named;
|
||||
mod newtype;
|
||||
mod tuple;
|
||||
mod type_as;
|
||||
mod type_override;
|
||||
mod unit;
|
||||
|
||||
pub(crate) use r#enum::r#enum_def;
|
||||
|
||||
use crate::utils::make_string_literal;
|
||||
|
||||
pub(crate) fn struct_def(s: &ItemStruct) -> Result<DerivedTS> {
|
||||
let attr = StructAttr::from_attrs(&s.attrs)?;
|
||||
|
||||
let ts_name = attr
|
||||
.rename
|
||||
.clone()
|
||||
.unwrap_or_else(|| make_string_literal(&s.ident.unraw().to_string(), s.ident.span()));
|
||||
type_def(&attr, ts_name, &s.fields)
|
||||
}
|
||||
|
||||
fn type_def(attr: &StructAttr, ts_name: Expr, fields: &Fields) -> Result<DerivedTS> {
|
||||
attr.assert_validity(fields)?;
|
||||
|
||||
if let Some(attr_type_override) = &attr.type_override {
|
||||
return type_override::type_override_struct(attr, ts_name, attr_type_override);
|
||||
}
|
||||
if let Some(attr_type_as) = &attr.type_as {
|
||||
return type_as::type_as_struct(attr, ts_name, attr_type_as);
|
||||
}
|
||||
|
||||
match fields {
|
||||
Fields::Named(named) => match named.named.len() {
|
||||
0 if attr.tag.is_none() => unit::empty_object(attr, ts_name),
|
||||
_ => named::named(attr, ts_name, named),
|
||||
},
|
||||
Fields::Unnamed(unnamed) => match unnamed.unnamed.len() {
|
||||
0 => unit::empty_array(attr, ts_name),
|
||||
1 => newtype::newtype(attr, ts_name, unnamed),
|
||||
_ => tuple::tuple(attr, ts_name, unnamed),
|
||||
},
|
||||
Fields::Unit => unit::null(attr, ts_name),
|
||||
}
|
||||
}
|
||||
|
||||
+190
-191
@@ -1,191 +1,190 @@
|
||||
use crate::{
|
||||
attr::{Attr, ContainerAttr, FieldAttr, Inflection, Optional, StructAttr},
|
||||
deps::Dependencies,
|
||||
utils::{raw_name_to_ts_field, to_ts_ident},
|
||||
DerivedTS,
|
||||
};
|
||||
use proc_macro2::TokenStream;
|
||||
use quote::{quote, quote_spanned};
|
||||
use syn::spanned::Spanned;
|
||||
use syn::{parse_quote, Field, FieldsNamed, Path, Result};
|
||||
|
||||
pub(crate) fn named(attr: &StructAttr, name: &str, fields: &FieldsNamed) -> Result<DerivedTS> {
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
let mut formatted_fields = Vec::new();
|
||||
let mut flattened_fields = Vec::new();
|
||||
let mut dependencies = Dependencies::new(crate_rename.clone());
|
||||
|
||||
if let Some(tag) = &attr.tag {
|
||||
let formatted = format!("\"{}\": \"{}\",", tag, name);
|
||||
formatted_fields.push(quote! {
|
||||
#formatted.to_string()
|
||||
});
|
||||
}
|
||||
|
||||
for field in &fields.named {
|
||||
format_field(
|
||||
&crate_rename,
|
||||
&mut formatted_fields,
|
||||
&mut flattened_fields,
|
||||
&mut dependencies,
|
||||
field,
|
||||
&attr.rename_all,
|
||||
attr.optional_fields,
|
||||
)?;
|
||||
}
|
||||
|
||||
let fields = quote!(<[String]>::join(&[#(#formatted_fields),*], " "));
|
||||
let flattened = quote!(<[String]>::join(&[#(#flattened_fields),*], " & "));
|
||||
|
||||
let inline = match (formatted_fields.len(), flattened_fields.len()) {
|
||||
(0, 0) => quote!("{ }".to_owned()),
|
||||
(_, 0) => quote!(format!("{{ {} }}", #fields)),
|
||||
(0, 1) => quote! {{
|
||||
if #flattened.starts_with('(') && #flattened.ends_with(')') {
|
||||
#flattened[1..#flattened.len() - 1].trim().to_owned()
|
||||
} else {
|
||||
#flattened.trim().to_owned()
|
||||
}
|
||||
}},
|
||||
(0, _) => quote!(#flattened),
|
||||
(_, _) => quote!(format!("{{ {} }} & {}", #fields, #flattened)),
|
||||
};
|
||||
|
||||
let inline_flattened = match (formatted_fields.len(), flattened_fields.len()) {
|
||||
(0, 0) => quote!("{ }".to_owned()),
|
||||
(_, 0) => quote!(format!("{{ {} }}", #fields)),
|
||||
(0, _) => quote!(#flattened),
|
||||
(_, _) => quote!(format!("{{ {} }} & {}", #fields, #flattened)),
|
||||
};
|
||||
|
||||
Ok(DerivedTS {
|
||||
crate_rename,
|
||||
// the `replace` combines `{ ... } & { ... }` into just one `{ ... }`. Not necessary, but it
|
||||
// results in simpler type definitions.
|
||||
inline: quote!(#inline.replace(" } & { ", " ")),
|
||||
inline_flattened: Some(quote!(#inline_flattened.replace(" } & { ", " "))),
|
||||
docs: attr.docs.clone(),
|
||||
dependencies,
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
// build an expression which expands to a string, representing a single field of a struct.
|
||||
//
|
||||
// formatted_fields will contain all the fields that do not contain the flatten
|
||||
// attribute, in the format
|
||||
// key: type,
|
||||
//
|
||||
// flattened_fields will contain all the fields that contain the flatten attribute
|
||||
// in their respective formats, which for a named struct is the same as formatted_fields,
|
||||
// but for enums is
|
||||
// ({ /* variant data */ } | { /* variant data */ })
|
||||
fn format_field(
|
||||
crate_rename: &Path,
|
||||
formatted_fields: &mut Vec<TokenStream>,
|
||||
flattened_fields: &mut Vec<TokenStream>,
|
||||
dependencies: &mut Dependencies,
|
||||
field: &Field,
|
||||
rename_all: &Option<Inflection>,
|
||||
struct_optional: Optional,
|
||||
) -> Result<()> {
|
||||
let field_attr = FieldAttr::from_attrs(&field.attrs)?;
|
||||
|
||||
field_attr.assert_validity(field)?;
|
||||
|
||||
if field_attr.skip {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if let Some(ref type_override) = field_attr.type_override {
|
||||
let field_name = to_ts_ident(field.ident.as_ref().unwrap());
|
||||
let name = match (field_attr.rename.as_ref(), rename_all) {
|
||||
(Some(rn), _) => rn.to_owned(),
|
||||
(None, Some(rn)) => rn.apply(&field_name),
|
||||
(None, None) => field_name,
|
||||
};
|
||||
let valid_name = raw_name_to_ts_field(name);
|
||||
|
||||
// Start every doc string with a newline, because when other characters are in front, it is not "understood" by VSCode
|
||||
let docs = match field_attr.docs.is_empty() {
|
||||
true => "".to_string(),
|
||||
false => format!("\n{}", &field_attr.docs),
|
||||
};
|
||||
|
||||
formatted_fields.push(quote! {
|
||||
format!("{}{}: {},", #docs, #valid_name, #type_override)
|
||||
});
|
||||
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let ty = field_attr.type_as(&field.ty);
|
||||
|
||||
let (optional_annotation, nullable) = match (struct_optional, field_attr.optional) {
|
||||
// `#[ts(optional)]` on field takes precedence, and is enforced **AT COMPILE TIME**
|
||||
(_, Optional::Optional { nullable }) => (
|
||||
// expression that evaluates to the string "?", but fails to compile if `ty` is not an `Option`.
|
||||
quote_spanned! { field.span() => {
|
||||
fn check_that_field_is_option<T: #crate_rename::IsOption>(_: std::marker::PhantomData<T>) {}
|
||||
let x: std::marker::PhantomData<#ty> = std::marker::PhantomData;
|
||||
check_that_field_is_option(x);
|
||||
"?"
|
||||
}},
|
||||
nullable,
|
||||
),
|
||||
// `#[ts(optional)]` on the struct acts as `#[ts(optional)]` on a field, but does not error on non-`Option`
|
||||
// fields. Instead, it is a no-op.
|
||||
(Optional::Optional { nullable }, _) => (
|
||||
quote! {
|
||||
if <#ty as #crate_rename::TS>::IS_OPTION { "?" } else { "" }
|
||||
},
|
||||
nullable,
|
||||
),
|
||||
_ => (quote!(""), true),
|
||||
};
|
||||
|
||||
let ty = if nullable {
|
||||
ty
|
||||
} else {
|
||||
parse_quote! {<#ty as #crate_rename::TS>::OptionInnerType}
|
||||
};
|
||||
|
||||
if field_attr.flatten {
|
||||
flattened_fields.push(quote!(<#ty as #crate_rename::TS>::inline_flattened()));
|
||||
dependencies.append_from(&ty);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let formatted_ty = if field_attr.inline {
|
||||
dependencies.append_from(&ty);
|
||||
quote!(<#ty as #crate_rename::TS>::inline())
|
||||
} else {
|
||||
dependencies.push(&ty);
|
||||
quote!(<#ty as #crate_rename::TS>::name())
|
||||
};
|
||||
|
||||
let field_name = to_ts_ident(field.ident.as_ref().unwrap());
|
||||
let name = match (field_attr.rename, rename_all) {
|
||||
(Some(rn), _) => rn,
|
||||
(None, Some(rn)) => rn.apply(&field_name),
|
||||
(None, None) => field_name,
|
||||
};
|
||||
let valid_name = raw_name_to_ts_field(name);
|
||||
|
||||
// Start every doc string with a newline, because when other characters are in front, it is not "understood" by VSCode
|
||||
let docs = match field_attr.docs.is_empty() {
|
||||
true => "".to_string(),
|
||||
false => format!("\n{}", &field_attr.docs),
|
||||
};
|
||||
|
||||
formatted_fields.push(quote! {
|
||||
format!("{}{}{}: {},", #docs, #valid_name, #optional_annotation, #formatted_ty)
|
||||
});
|
||||
|
||||
Ok(())
|
||||
}
|
||||
use proc_macro2::TokenStream;
|
||||
use quote::{quote, quote_spanned};
|
||||
use syn::{parse_quote, spanned::Spanned, Expr, Field, FieldsNamed, Path, Result};
|
||||
|
||||
use crate::{
|
||||
attr::{Attr, ContainerAttr, FieldAttr, Inflection, Optional, StructAttr},
|
||||
deps::Dependencies,
|
||||
utils::{raw_name_to_ts_field, to_ts_ident},
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
pub(crate) fn named(attr: &StructAttr, ts_name: Expr, fields: &FieldsNamed) -> Result<DerivedTS> {
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
let mut formatted_fields = Vec::new();
|
||||
let mut flattened_fields = Vec::new();
|
||||
let mut dependencies = Dependencies::new(crate_rename.clone());
|
||||
|
||||
if let Some(tag) = &attr.tag {
|
||||
formatted_fields.push(quote! {
|
||||
format!("\"{}\": \"{}\",", #tag, #ts_name)
|
||||
});
|
||||
}
|
||||
|
||||
for field in &fields.named {
|
||||
format_field(
|
||||
&crate_rename,
|
||||
&mut formatted_fields,
|
||||
&mut flattened_fields,
|
||||
&mut dependencies,
|
||||
field,
|
||||
&attr.rename_all,
|
||||
attr.optional_fields,
|
||||
)?;
|
||||
}
|
||||
|
||||
let fields = quote!(<[String]>::join(&[#(#formatted_fields),*], " "));
|
||||
let flattened = quote!(<[String]>::join(&[#(#flattened_fields),*], " & "));
|
||||
|
||||
let inline = match (formatted_fields.len(), flattened_fields.len()) {
|
||||
(0, 0) => quote!("{ }".to_owned()),
|
||||
(_, 0) => quote!(format!("{{ {} }}", #fields)),
|
||||
(0, 1) => quote! {{
|
||||
if #flattened.starts_with('(') && #flattened.ends_with(')') {
|
||||
#flattened[1..#flattened.len() - 1].trim().to_owned()
|
||||
} else {
|
||||
#flattened.trim().to_owned()
|
||||
}
|
||||
}},
|
||||
(0, _) => quote!(#flattened),
|
||||
(_, _) => quote!(format!("{{ {} }} & {}", #fields, #flattened)),
|
||||
};
|
||||
|
||||
let inline_flattened = match (formatted_fields.len(), flattened_fields.len()) {
|
||||
(0, 0) => quote!("{ }".to_owned()),
|
||||
(_, 0) => quote!(format!("{{ {} }}", #fields)),
|
||||
(0, _) => quote!(#flattened),
|
||||
(_, _) => quote!(format!("{{ {} }} & {}", #fields, #flattened)),
|
||||
};
|
||||
|
||||
Ok(DerivedTS {
|
||||
crate_rename,
|
||||
// the `replace` combines `{ ... } & { ... }` into just one `{ ... }`. Not necessary, but it
|
||||
// results in simpler type definitions.
|
||||
inline: quote!(#inline.replace(" } & { ", " ")),
|
||||
inline_flattened: Some(quote!(#inline_flattened.replace(" } & { ", " "))),
|
||||
docs: attr.docs.clone(),
|
||||
dependencies,
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
// build an expression which expands to a string, representing a single field of a struct.
|
||||
//
|
||||
// formatted_fields will contain all the fields that do not contain the flatten
|
||||
// attribute, in the format
|
||||
// key: type,
|
||||
//
|
||||
// flattened_fields will contain all the fields that contain the flatten attribute
|
||||
// in their respective formats, which for a named struct is the same as formatted_fields,
|
||||
// but for enums is
|
||||
// ({ /* variant data */ } | { /* variant data */ })
|
||||
fn format_field(
|
||||
crate_rename: &Path,
|
||||
formatted_fields: &mut Vec<TokenStream>,
|
||||
flattened_fields: &mut Vec<TokenStream>,
|
||||
dependencies: &mut Dependencies,
|
||||
field: &Field,
|
||||
rename_all: &Option<Inflection>,
|
||||
struct_optional: Optional,
|
||||
) -> Result<()> {
|
||||
let field_attr = FieldAttr::from_attrs(&field.attrs)?;
|
||||
|
||||
field_attr.assert_validity(field)?;
|
||||
|
||||
if field_attr.skip {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if let Some(ref type_override) = field_attr.type_override {
|
||||
let field_name = to_ts_ident(field.ident.as_ref().unwrap());
|
||||
let name = match (field_attr.rename.as_ref(), rename_all) {
|
||||
(Some(rn), _) => rn.to_owned(),
|
||||
(None, Some(rn)) => rn.apply(&field_name),
|
||||
(None, None) => field_name,
|
||||
};
|
||||
let valid_name = raw_name_to_ts_field(name);
|
||||
|
||||
// Start every doc string with a newline, because when other characters are in front, it is not "understood" by VSCode
|
||||
let docs = match field_attr.docs.is_empty() {
|
||||
true => "".to_string(),
|
||||
false => format!("\n{}", &field_attr.docs),
|
||||
};
|
||||
|
||||
formatted_fields.push(quote! {
|
||||
format!("{}{}: {},", #docs, #valid_name, #type_override)
|
||||
});
|
||||
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let ty = field_attr.type_as(&field.ty);
|
||||
|
||||
let (optional_annotation, nullable) = match (struct_optional, field_attr.optional) {
|
||||
// `#[ts(optional)]` on field takes precedence, and is enforced **AT COMPILE TIME**
|
||||
(_, Optional::Optional { nullable }) => (
|
||||
// expression that evaluates to the string "?", but fails to compile if `ty` is not an `Option`.
|
||||
quote_spanned! { field.span() => {
|
||||
fn check_that_field_is_option<T: #crate_rename::IsOption>(_: std::marker::PhantomData<T>) {}
|
||||
let x: std::marker::PhantomData<#ty> = std::marker::PhantomData;
|
||||
check_that_field_is_option(x);
|
||||
"?"
|
||||
}},
|
||||
nullable,
|
||||
),
|
||||
// `#[ts(optional)]` on the struct acts as `#[ts(optional)]` on a field, but does not error on non-`Option`
|
||||
// fields. Instead, it is a no-op.
|
||||
(Optional::Optional { nullable }, _) => (
|
||||
quote! {
|
||||
if <#ty as #crate_rename::TS>::IS_OPTION { "?" } else { "" }
|
||||
},
|
||||
nullable,
|
||||
),
|
||||
_ => (quote!(""), true),
|
||||
};
|
||||
|
||||
let ty = if nullable {
|
||||
ty
|
||||
} else {
|
||||
parse_quote! {<#ty as #crate_rename::TS>::OptionInnerType}
|
||||
};
|
||||
|
||||
if field_attr.flatten {
|
||||
flattened_fields.push(quote!(<#ty as #crate_rename::TS>::inline_flattened()));
|
||||
dependencies.append_from(&ty);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let formatted_ty = if field_attr.inline {
|
||||
dependencies.append_from(&ty);
|
||||
quote!(<#ty as #crate_rename::TS>::inline())
|
||||
} else {
|
||||
dependencies.push(&ty);
|
||||
quote!(<#ty as #crate_rename::TS>::name())
|
||||
};
|
||||
|
||||
let field_name = to_ts_ident(field.ident.as_ref().unwrap());
|
||||
let name = match (field_attr.rename, rename_all) {
|
||||
(Some(rn), _) => rn,
|
||||
(None, Some(rn)) => rn.apply(&field_name),
|
||||
(None, None) => field_name,
|
||||
};
|
||||
let valid_name = raw_name_to_ts_field(name);
|
||||
|
||||
// Start every doc string with a newline, because when other characters are in front, it is not "understood" by VSCode
|
||||
let docs = match field_attr.docs.is_empty() {
|
||||
true => "".to_string(),
|
||||
false => format!("\n{}", &field_attr.docs),
|
||||
};
|
||||
|
||||
formatted_fields.push(quote! {
|
||||
format!("{}{}{}: {},", #docs, #valid_name, #optional_annotation, #formatted_ty)
|
||||
});
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use quote::quote;
|
||||
use syn::{FieldsUnnamed, Result};
|
||||
use syn::{Expr, FieldsUnnamed, Result};
|
||||
|
||||
use crate::{
|
||||
attr::{Attr, ContainerAttr, FieldAttr, StructAttr},
|
||||
@@ -7,7 +7,11 @@ use crate::{
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
pub(crate) fn newtype(attr: &StructAttr, name: &str, fields: &FieldsUnnamed) -> Result<DerivedTS> {
|
||||
pub(crate) fn newtype(
|
||||
attr: &StructAttr,
|
||||
ts_name: Expr,
|
||||
fields: &FieldsUnnamed,
|
||||
) -> Result<DerivedTS> {
|
||||
let inner = fields.unnamed.first().unwrap();
|
||||
|
||||
let field_attr = FieldAttr::from_attrs(&inner.attrs)?;
|
||||
@@ -16,7 +20,7 @@ pub(crate) fn newtype(attr: &StructAttr, name: &str, fields: &FieldsUnnamed) ->
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
if field_attr.skip {
|
||||
return super::unit::null(attr, name);
|
||||
return super::unit::null(attr, ts_name);
|
||||
}
|
||||
|
||||
let inner_ty = field_attr.type_as(&inner.ty);
|
||||
@@ -43,7 +47,7 @@ pub(crate) fn newtype(attr: &StructAttr, name: &str, fields: &FieldsUnnamed) ->
|
||||
dependencies,
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use proc_macro2::TokenStream;
|
||||
use quote::quote;
|
||||
use syn::{Field, FieldsUnnamed, Path, Result};
|
||||
use syn::{Expr, Field, FieldsUnnamed, Path, Result};
|
||||
|
||||
use crate::{
|
||||
attr::{Attr, ContainerAttr, FieldAttr, StructAttr},
|
||||
@@ -8,7 +8,7 @@ use crate::{
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
pub(crate) fn tuple(attr: &StructAttr, name: &str, fields: &FieldsUnnamed) -> Result<DerivedTS> {
|
||||
pub(crate) fn tuple(attr: &StructAttr, ts_name: Expr, fields: &FieldsUnnamed) -> Result<DerivedTS> {
|
||||
let crate_rename = attr.crate_rename();
|
||||
let mut formatted_fields = Vec::new();
|
||||
let mut dependencies = Dependencies::new(crate_rename.clone());
|
||||
@@ -34,7 +34,7 @@ pub(crate) fn tuple(attr: &StructAttr, name: &str, fields: &FieldsUnnamed) -> Re
|
||||
dependencies,
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use quote::quote;
|
||||
use syn::{Result, Type};
|
||||
use syn::{Expr, Result, Type};
|
||||
|
||||
use crate::{
|
||||
attr::{ContainerAttr, EnumAttr, StructAttr},
|
||||
@@ -7,7 +7,11 @@ use crate::{
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
pub(crate) fn type_as_struct(attr: &StructAttr, name: &str, type_as: &Type) -> Result<DerivedTS> {
|
||||
pub(crate) fn type_as_struct(
|
||||
attr: &StructAttr,
|
||||
ts_name: Expr,
|
||||
type_as: &Type,
|
||||
) -> Result<DerivedTS> {
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
let mut dependencies = Dependencies::new(crate_rename.clone());
|
||||
@@ -21,13 +25,13 @@ pub(crate) fn type_as_struct(attr: &StructAttr, name: &str, type_as: &Type) -> R
|
||||
dependencies,
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn type_as_enum(attr: &EnumAttr, name: &str, type_as: &Type) -> Result<DerivedTS> {
|
||||
pub(crate) fn type_as_enum(attr: &EnumAttr, ts_name: Expr, type_as: &Type) -> Result<DerivedTS> {
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
let mut dependencies = Dependencies::new(crate_rename.clone());
|
||||
@@ -41,7 +45,7 @@ pub(crate) fn type_as_enum(attr: &EnumAttr, name: &str, type_as: &Type) -> Resul
|
||||
dependencies,
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use quote::quote;
|
||||
use syn::Result;
|
||||
use syn::{Expr, Result};
|
||||
|
||||
use crate::{
|
||||
attr::{ContainerAttr, EnumAttr, StructAttr},
|
||||
@@ -9,7 +9,7 @@ use crate::{
|
||||
|
||||
pub(crate) fn type_override_struct(
|
||||
attr: &StructAttr,
|
||||
name: &str,
|
||||
ts_name: Expr,
|
||||
type_override: &str,
|
||||
) -> Result<DerivedTS> {
|
||||
let crate_rename = attr.crate_rename();
|
||||
@@ -22,7 +22,7 @@ pub(crate) fn type_override_struct(
|
||||
dependencies: Dependencies::new(crate_rename),
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
@@ -30,7 +30,7 @@ pub(crate) fn type_override_struct(
|
||||
|
||||
pub(crate) fn type_override_enum(
|
||||
attr: &EnumAttr,
|
||||
name: &str,
|
||||
ts_name: Expr,
|
||||
type_override: &str,
|
||||
) -> Result<DerivedTS> {
|
||||
let crate_rename = attr.crate_rename();
|
||||
@@ -43,7 +43,7 @@ pub(crate) fn type_override_enum(
|
||||
dependencies: Dependencies::new(crate_rename),
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use quote::quote;
|
||||
use syn::Result;
|
||||
use syn::{Expr, Result};
|
||||
|
||||
use crate::{
|
||||
attr::{ContainerAttr, StructAttr},
|
||||
@@ -7,7 +7,7 @@ use crate::{
|
||||
DerivedTS,
|
||||
};
|
||||
|
||||
pub(crate) fn empty_object(attr: &StructAttr, name: &str) -> Result<DerivedTS> {
|
||||
pub(crate) fn empty_object(attr: &StructAttr, ts_name: Expr) -> Result<DerivedTS> {
|
||||
check_attributes(attr)?;
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
@@ -19,13 +19,13 @@ pub(crate) fn empty_object(attr: &StructAttr, name: &str) -> Result<DerivedTS> {
|
||||
dependencies: Dependencies::new(crate_rename),
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn empty_array(attr: &StructAttr, name: &str) -> Result<DerivedTS> {
|
||||
pub(crate) fn empty_array(attr: &StructAttr, ts_name: Expr) -> Result<DerivedTS> {
|
||||
check_attributes(attr)?;
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
@@ -37,13 +37,13 @@ pub(crate) fn empty_array(attr: &StructAttr, name: &str) -> Result<DerivedTS> {
|
||||
dependencies: Dependencies::new(crate_rename),
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn null(attr: &StructAttr, name: &str) -> Result<DerivedTS> {
|
||||
pub(crate) fn null(attr: &StructAttr, ts_name: Expr) -> Result<DerivedTS> {
|
||||
check_attributes(attr)?;
|
||||
let crate_rename = attr.crate_rename();
|
||||
|
||||
@@ -55,7 +55,7 @@ pub(crate) fn null(attr: &StructAttr, name: &str) -> Result<DerivedTS> {
|
||||
dependencies: Dependencies::new(crate_rename),
|
||||
export: attr.export,
|
||||
export_to: attr.export_to.clone(),
|
||||
ts_name: name.to_owned(),
|
||||
ts_name,
|
||||
concrete: attr.concrete.clone(),
|
||||
bound: attr.bound.clone(),
|
||||
})
|
||||
|
||||
+10
-3
@@ -1,10 +1,10 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use proc_macro2::{Ident, TokenStream};
|
||||
use proc_macro2::{Ident, Span, TokenStream};
|
||||
use quote::quote;
|
||||
use syn::{
|
||||
spanned::Spanned, Attribute, Error, Expr, ExprLit, GenericParam, Generics, Lit, Path, Result,
|
||||
Type,
|
||||
spanned::Spanned, Attribute, Error, Expr, ExprLit, GenericParam, Generics, Lit, LitStr, Path,
|
||||
Result, Type,
|
||||
};
|
||||
|
||||
use super::attr::{Attr, Serde};
|
||||
@@ -313,3 +313,10 @@ pub fn format_generics(
|
||||
let comma_separated = quote!([#(#expanded_params),*].join(", "));
|
||||
quote!(format!("<{}>", #comma_separated))
|
||||
}
|
||||
|
||||
pub fn make_string_literal(content: &str, span: Span) -> Expr {
|
||||
Expr::Lit(ExprLit {
|
||||
attrs: vec![],
|
||||
lit: Lit::Str(LitStr::new(content, span)),
|
||||
})
|
||||
}
|
||||
|
||||
+1
-1
@@ -342,7 +342,7 @@ fn generate_imports<T: TS + ?Sized + 'static>(
|
||||
let mut imports: BTreeMap<String, BTreeSet<&str>> = Default::default();
|
||||
|
||||
for (_, dep) in deduplicated_deps {
|
||||
let dep_path = out_dir.as_ref().join(dep.output_path);
|
||||
let dep_path = out_dir.as_ref().join(&dep.output_path);
|
||||
let rel_path = import_path(&path, &dep_path)?;
|
||||
|
||||
let is_same_file = path
|
||||
|
||||
+9
-7
@@ -208,7 +208,7 @@ mod tokio;
|
||||
/// <br/><br/>
|
||||
///
|
||||
/// - **`#[ts(as = "..")]`**
|
||||
/// Overrides the type used in Typescript, using the provided Rust type instead.
|
||||
/// Overrides the type used in Typescript, using the provided Rust type instead.
|
||||
/// This is useful when you have a custom serializer and deserializer and don't want to implement `TS` manually
|
||||
/// <br/><br/>
|
||||
///
|
||||
@@ -218,7 +218,8 @@ mod tokio;
|
||||
/// <br/><br/>
|
||||
///
|
||||
/// - **`#[ts(rename = "..")]`**
|
||||
/// Sets the typescript name of the generated type
|
||||
/// Sets the typescript name of the generated type.
|
||||
/// Also accepts expressions, e.g `#[ts(rename = module_path!().rsplit_once("::").unwrap().1)]`.
|
||||
/// <br/><br/>
|
||||
///
|
||||
/// - **`#[ts(rename_all = "..")]`**
|
||||
@@ -358,7 +359,8 @@ mod tokio;
|
||||
/// ### enum variant attributes
|
||||
///
|
||||
/// - **`#[ts(rename = "..")]`**
|
||||
/// Renames this variant. To rename all variants of an enum, see the container attribute `#[ts(rename_all = "..")]`.
|
||||
/// Renames this variant. To rename all variants of an enum, see the container attribute `#[ts(rename_all = "..")]`.
|
||||
/// This attribute also accepts expressions, e.g `#[ts(rename = module_path!().rsplit_once("::").unwrap().1)]`.
|
||||
/// <br/><br/>
|
||||
///
|
||||
/// - **`#[ts(skip)]`**
|
||||
@@ -575,7 +577,7 @@ pub trait TS {
|
||||
///
|
||||
/// If `T` cannot be exported (e.g because it's a primitive type), this function will return
|
||||
/// `None`.
|
||||
fn output_path() -> Option<&'static Path> {
|
||||
fn output_path() -> Option<PathBuf> {
|
||||
None
|
||||
}
|
||||
|
||||
@@ -613,10 +615,10 @@ pub struct Dependency {
|
||||
pub type_id: TypeId,
|
||||
/// Name of the type in TypeScript
|
||||
pub ts_name: String,
|
||||
/// Path to where the type would be exported. By default a filename is derived from the types
|
||||
/// Path to where the type would be exported. By default, a filename is derived from the types
|
||||
/// name, which can be customized with `#[ts(export_to = "..")]`.
|
||||
/// This path does _not_ include a base directory.
|
||||
pub output_path: &'static Path,
|
||||
pub output_path: PathBuf,
|
||||
}
|
||||
|
||||
impl Dependency {
|
||||
@@ -743,7 +745,7 @@ macro_rules! impl_shadow {
|
||||
}
|
||||
fn decl() -> String { <$s as $crate::TS>::decl() }
|
||||
fn decl_concrete() -> String { <$s as $crate::TS>::decl_concrete() }
|
||||
fn output_path() -> Option<&'static std::path::Path> { <$s as $crate::TS>::output_path() }
|
||||
fn output_path() -> Option<std::path::PathBuf> { <$s as $crate::TS>::output_path() }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@@ -20,7 +20,7 @@ trait Malicious {
|
||||
fn export_all() -> Result<(), ExportError> { unimplemented!() }
|
||||
fn export_all_to(out_dir: impl AsRef<Path>) -> Result<(), ExportError> { unimplemented!() }
|
||||
fn export_to_string() -> Result<String, ExportError> { unimplemented!() }
|
||||
fn output_path() -> Option<&'static Path> { unimplemented!() }
|
||||
fn output_path() -> Option<PathBuf> { unimplemented!() }
|
||||
fn default_output_path() -> Option<PathBuf> { unimplemented!() }
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
#[macro_export]
|
||||
macro_rules! get_model_name {
|
||||
() => {{
|
||||
let mut module = module_path!().rsplit_once("::").unwrap().1.to_owned();
|
||||
module[0..1].make_ascii_uppercase();
|
||||
format!("{module}Model")
|
||||
}};
|
||||
}
|
||||
|
||||
mod entities {
|
||||
mod users {
|
||||
use ts_rs::TS;
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export)]
|
||||
#[ts(export_to = "issue_397/")]
|
||||
#[ts(rename = {
|
||||
let mut module = module_path!().rsplit_once("::").unwrap().1.to_owned();
|
||||
module[0..1].make_ascii_uppercase();
|
||||
format!("{module}Model")
|
||||
})]
|
||||
struct Model;
|
||||
}
|
||||
|
||||
mod posts {
|
||||
use ts_rs::TS;
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export)]
|
||||
#[ts(export_to = "issue_397/")]
|
||||
#[ts(rename = get_model_name!())]
|
||||
struct Model;
|
||||
}
|
||||
}
|
||||
@@ -29,6 +29,7 @@ mod issue_232;
|
||||
mod issue_308;
|
||||
mod issue_317;
|
||||
mod issue_338;
|
||||
mod issue_397;
|
||||
mod issue_70;
|
||||
mod issue_80;
|
||||
mod leading_colon;
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
use serde::de::Expected;
|
||||
use std::fmt::Write;
|
||||
|
||||
use serde::de::Expected;
|
||||
use ts_rs::TS;
|
||||
|
||||
#[derive(TS)]
|
||||
|
||||
@@ -77,3 +77,73 @@ struct RenameSerdeSpecialChar {
|
||||
fn serde_rename_special_char() {
|
||||
assert_eq!(RenameSerdeSpecialChar::inline(), r#"{ "a/b": number, }"#);
|
||||
}
|
||||
|
||||
// struct-level renames
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export, export_to = "struct_rename/")]
|
||||
#[ts(rename = "RenamedWithStrLiteral")]
|
||||
enum WithStrLiteral {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_with_str_literal() {
|
||||
assert_eq!(
|
||||
WithStrLiteral::decl(),
|
||||
r#"type RenamedWithStrLiteral = "A" | "B" | "C";"#
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export, export_to = "struct_rename/")]
|
||||
#[ts(rename = format!("{}With{}", "Renamed", "StringExpression"))]
|
||||
enum WithStringExpression {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_with_string_expression() {
|
||||
assert_eq!(
|
||||
WithStringExpression::decl(),
|
||||
r#"type RenamedWithStringExpression = "A" | "B" | "C";"#
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export, export_to = "struct_rename/")]
|
||||
#[ts(rename = &"RenamedWithStrExpression")]
|
||||
enum WithStrExpression {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_with_str_expression() {
|
||||
assert_eq!(
|
||||
WithStrExpression::decl(),
|
||||
r#"type RenamedWithStrExpression = "A" | "B" | "C";"#
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export, export_to = "struct_rename/")]
|
||||
#[ts(rename = format!("i_am_inside_module_{}", module_path!().rsplit_once("::").unwrap().1))]
|
||||
enum RenameUsingModuleName {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_using_module_name() {
|
||||
assert_eq!(
|
||||
RenameUsingModuleName::decl(),
|
||||
r#"type i_am_inside_module_struct_rename = "A" | "B" | "C";"#
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[cfg(feature = "serde-json-impl")]
|
||||
use serde_json::Value as JsonValue;
|
||||
use std::collections::HashMap;
|
||||
use ts_rs::TS;
|
||||
|
||||
#[derive(TS)]
|
||||
|
||||
@@ -9,6 +9,7 @@ enum SimpleEnum {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
r#D,
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -23,6 +24,6 @@ fn test_empty() {
|
||||
fn test_simple_enum() {
|
||||
assert_eq!(
|
||||
SimpleEnum::decl(),
|
||||
r#"type SimpleEnum = "asdf" | "B" | "C";"#
|
||||
r#"type SimpleEnum = "asdf" | "B" | "C" | "D";"#
|
||||
)
|
||||
}
|
||||
|
||||
@@ -8,7 +8,9 @@ use ts_rs::TS;
|
||||
enum RenamedEnum {
|
||||
#[ts(rename = "ASDF")]
|
||||
A,
|
||||
#[ts(rename = &"BB")]
|
||||
B,
|
||||
#[ts(rename = "C".repeat(2))]
|
||||
C,
|
||||
}
|
||||
|
||||
@@ -16,6 +18,57 @@ enum RenamedEnum {
|
||||
fn test_simple_enum() {
|
||||
assert_eq!(
|
||||
RenamedEnum::decl(),
|
||||
r#"type SimpleEnum = "ASDF" | "b" | "c";"#
|
||||
r#"type SimpleEnum = "ASDF" | "BB" | "CC";"#
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export, export_to = "union_rename/")]
|
||||
#[ts(rename = format!("{}With{}", "Renamed", "StringExpression"))]
|
||||
enum WithStringExpression {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_with_string_expression() {
|
||||
assert_eq!(
|
||||
WithStringExpression::decl(),
|
||||
r#"type RenamedWithStringExpression = "A" | "B" | "C";"#
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export, export_to = "union_rename/")]
|
||||
#[ts(rename = &"RenamedWithStrExpression")]
|
||||
enum WithStrExpression {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_with_str_expression() {
|
||||
assert_eq!(
|
||||
WithStrExpression::decl(),
|
||||
r#"type RenamedWithStrExpression = "A" | "B" | "C";"#
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(TS)]
|
||||
#[ts(export, export_to = "union_rename/")]
|
||||
#[ts(rename = format!("i_am_inside_module_{}", module_path!().rsplit_once("::").unwrap().1))]
|
||||
enum RenameUsingModuleName {
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_using_module_name() {
|
||||
assert_eq!(
|
||||
RenameUsingModuleName::decl(),
|
||||
r#"type i_am_inside_module_union_rename = "A" | "B" | "C";"#
|
||||
)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user