89 lines
2.9 KiB
Rust
89 lines
2.9 KiB
Rust
use darling::FromDeriveInput;
|
|
use proc_macro::TokenStream;
|
|
use proc_macro2::{Span as Span2, TokenStream as TokenStream2};
|
|
use quote::{ToTokens, quote};
|
|
use syn::{Ident, LitStr, Path, parse_quote, parse2};
|
|
|
|
#[derive(FromDeriveInput)]
|
|
#[darling(supports(struct_unit))]
|
|
#[darling(attributes(string_literal))]
|
|
struct StringLiteral {
|
|
ident: Ident,
|
|
value: String,
|
|
}
|
|
|
|
impl ToTokens for StringLiteral {
|
|
fn to_tokens(&self, tokens: &mut TokenStream2) {
|
|
let Self { ident, value } = self;
|
|
|
|
dbg!("reached this point");
|
|
|
|
let as_ref_trait: Path = parse_quote!(::core::convert::AsRef);
|
|
let display_trait: Path = parse_quote!(::std::fmt::Display);
|
|
let from_trait: Path = parse_quote!(::core::convert::From);
|
|
let from_str_trait: Path = parse_quote!(::std::str::FromStr);
|
|
let result: Path = parse_quote!(::core::result::Result);
|
|
let wrong_literal_error_generic: Path = parse_quote!(::string_literal::WrongLiteralError);
|
|
let wrong_literal_error: Path = parse_quote!(#wrong_literal_error_generic<#ident>);
|
|
let write_macro: Path = parse_quote!(::std::write);
|
|
|
|
let value_literal = LitStr::new(value.as_str(), Span2::call_site());
|
|
|
|
dbg!("reached this point");
|
|
|
|
let output = quote! {
|
|
impl #from_trait<#ident> for &'static str {
|
|
fn from(unit: #ident) -> Self {
|
|
#value_literal
|
|
}
|
|
}
|
|
|
|
impl #from_str_trait for #ident {
|
|
type Err = #wrong_literal_error;
|
|
|
|
fn from_str(s: &str) -> #result<Self, Self::Err> {
|
|
if s == #value_literal {
|
|
Ok(Self)
|
|
} else {
|
|
Err(#wrong_literal_error_generic { actual: s.to_owned(), expected: #ident })
|
|
}
|
|
}
|
|
}
|
|
|
|
impl #display_trait for #ident {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
#write_macro!(f, "state_changed")
|
|
}
|
|
}
|
|
|
|
impl #as_ref_trait<str> for #ident {
|
|
fn as_ref(&self) -> &str {
|
|
#value_literal
|
|
}
|
|
}
|
|
};
|
|
dbg!(&output.to_string());
|
|
|
|
tokens.extend(output);
|
|
}
|
|
}
|
|
|
|
fn string_literal_impl(input: TokenStream2) -> TokenStream2 {
|
|
let derive_input = match parse2(input) {
|
|
Ok(derive_input) => derive_input,
|
|
Err(error) => return error.into_compile_error(),
|
|
};
|
|
|
|
let string_literal = match StringLiteral::from_derive_input(&derive_input) {
|
|
Ok(string_literal) => string_literal,
|
|
Err(error) => return error.write_errors(),
|
|
};
|
|
|
|
quote! { #string_literal }
|
|
}
|
|
|
|
#[proc_macro_derive(StringLiteral, attributes(string_literal))]
|
|
pub fn string_literal(input: TokenStream) -> TokenStream {
|
|
string_literal_impl(input.into()).into()
|
|
}
|