use darling::{
ast::Data as DarlingData, util::Ignored, Error as DarlingError, FromDeriveInput, FromVariant,
};
use serde_attributes::Alias;
use syn::{parse_str, Data, DataEnum, DeriveInput, Meta, MetaList, NestedMeta};
#[allow(dead_code)]
pub fn parse_serde_meta(input: &str) -> Meta {
parse_serde_meta_list(input).first().cloned().unwrap()
}
pub fn parse_serde_meta_list(input: &str) -> Vec {
let derive_input = parse_str::(input).unwrap();
let attrs = &derive_input.attrs;
match attrs[0].parse_meta().unwrap() {
Meta::List(MetaList {
path,
paren_token: _,
nested: _,
}) if path.is_ident("derive") => {}
meta => {
println!("{meta:?}");
panic!()
}
}
match derive_input.data {
Data::Enum(DataEnum {
enum_token: _,
brace_token: _,
variants,
}) => {
let attrs = &variants[0].attrs;
attrs
.iter()
.map(|attr| match attr.parse_meta().unwrap() {
Meta::List(MetaList {
path,
paren_token: _,
nested,
}) if path.is_ident("serde") => match nested.first().cloned() {
Some(NestedMeta::Meta(meta)) => meta,
_ => panic!(),
},
meta => {
println!("{meta:?}");
panic!()
}
})
.collect()
}
data => {
println!("{data:?}");
panic!()
}
}
}
pub fn parse_darling_alias(input: &str) -> Result, DarlingError> {
#[derive(FromDeriveInput)]
#[darling(attributes(serde))]
struct SerdeDerive {
data: DarlingData,
}
#[derive(FromVariant, Debug, Clone)]
#[darling(attributes(serde))]
struct SerdeVariant {
#[darling(default, multiple, rename = "alias")]
alias_vec: Vec,
}
let derive = SerdeDerive::from_derive_input(
&parse_str(
input
.replace(
r#"#[derive(serde::Serialize, serde::Deserialize)]"#,
r#"#[derive(SerdeDerive)]"#,
)
.as_str(),
)
.unwrap(),
)?;
let variants = match &derive.data {
DarlingData::Enum(variants) => variants,
_ => {
println!("{:?}", derive.data);
panic!()
}
};
Ok(variants[0].to_owned().alias_vec)
}