mirror of
https://codeberg.org/unspeaker/tengri.git
synced 2025-12-06 11:46:42 +01:00
251 lines
9 KiB
Rust
251 lines
9 KiB
Rust
use crate::*;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct CommandDef(pub(crate) CommandMeta, pub(crate) CommandImpl);
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct CommandMeta(Ident);
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct CommandImpl(ItemImpl, BTreeMap<Arc<str>, CommandArm>);
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct CommandArm(Ident, Vec<FnArg>, ReturnType);
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct CommandVariant(Ident, Vec<FnArg>);
|
|
|
|
impl Parse for CommandMeta {
|
|
fn parse (input: ParseStream) -> Result<Self> {
|
|
Ok(Self(input.parse::<Ident>()?))
|
|
}
|
|
}
|
|
|
|
impl Parse for CommandImpl {
|
|
fn parse (input: ParseStream) -> Result<Self> {
|
|
let block = input.parse::<ItemImpl>()?;
|
|
let exposed = Self::collect(&block.items).map_err(|e|input.error(e))?;
|
|
Ok(Self(block, exposed))
|
|
}
|
|
}
|
|
|
|
impl CommandImpl {
|
|
fn collect (items: &Vec<ImplItem>)
|
|
-> std::result::Result<BTreeMap<Arc<str>, CommandArm>, String>
|
|
{
|
|
let mut exposed: BTreeMap<Arc<str>, CommandArm> = Default::default();
|
|
for item in items.iter() {
|
|
if let ImplItem::Fn(
|
|
ImplItemFn { sig: Signature { ident, inputs, output, .. }, .. }
|
|
) = item {
|
|
let key = CommandArm::ident_to_key(&ident);
|
|
if exposed.contains_key(&key) {
|
|
return Err(format!("already defined: {ident}"));
|
|
}
|
|
exposed.insert(key, CommandArm(
|
|
ident.clone(),
|
|
inputs.iter().map(|x|x.clone()).collect(),
|
|
output.clone(),
|
|
));
|
|
}
|
|
}
|
|
Ok(exposed)
|
|
}
|
|
}
|
|
|
|
impl ToTokens for CommandDef {
|
|
fn to_tokens (&self, out: &mut TokenStream2) {
|
|
let Self(CommandMeta(target), CommandImpl(block, exposed)) = self;
|
|
let enumeration = &block.self_ty;
|
|
let variants = exposed.values().map(|x|x.to_enum_variant_def());
|
|
let matchers = exposed.values().map(CommandArm::to_matcher);
|
|
let implementations = exposed.values().map(CommandArm::to_implementation);
|
|
write_quote_to(out, quote! {
|
|
/// Generated by [tengri_proc].
|
|
#[derive(Clone, Debug)]
|
|
pub enum #enumeration {
|
|
#(#variants)*
|
|
}
|
|
#block
|
|
/// Generated by [tengri_proc].
|
|
impl<'a> TryFromDsl<'a, #target> for #enumeration {
|
|
fn try_from_expr (state: &#target, iter: TokenIter) -> Option<Self> {
|
|
let mut iter = iter.clone();
|
|
match iter.next() {
|
|
#(#matchers)*
|
|
_ => None
|
|
}
|
|
}
|
|
}
|
|
/// Generated by [tengri_proc].
|
|
impl Command<#target> for #enumeration {
|
|
fn execute (self, state: &mut #target) -> Perhaps<Self> {
|
|
match self {
|
|
#(#implementations)*
|
|
}
|
|
}
|
|
}
|
|
});
|
|
//if exposed.len() > 0 {
|
|
//panic!("{:#?}", block.self_ty);
|
|
//if let Type::Path(ref path) = *block.self_ty {
|
|
//if path.path.segments.get(0).unwrap().ident == "TekCommand" {
|
|
//panic!("\n{}", quote! {#out});
|
|
//}
|
|
//}
|
|
}
|
|
}
|
|
|
|
impl CommandArm {
|
|
fn to_key (&self) -> Arc<str> {
|
|
Self::ident_to_key(&self.0)
|
|
}
|
|
fn to_enum_variant_ident (&self) -> Ident {
|
|
Ident::new(&Self::ident_to_enum_variant(&self.0), Span::call_site())
|
|
}
|
|
fn ident_to_key (ident: &Ident) -> Arc<str> {
|
|
format!("{}", AsKebabCase(format!("{ident}"))).into()
|
|
}
|
|
fn ident_to_enum_variant (ident: &Ident) -> Arc<str> {
|
|
format!("{}", AsUpperCamelCase(format!("{ident}"))).into()
|
|
}
|
|
fn has_args (&self) -> bool {
|
|
self.1.len() > 1
|
|
}
|
|
fn args (&self) -> impl Iterator<Item = (&Ident, &Box<Type>)> {
|
|
self.1.iter().skip(1).filter_map(|arg|if let FnArg::Typed(PatType {
|
|
ty, pat: box Pat::Ident(PatIdent { ident: arg, .. }), ..
|
|
}) = arg {
|
|
Some((arg, ty))
|
|
} else {
|
|
unreachable!("only typed args should be present at this position");
|
|
None
|
|
})
|
|
}
|
|
fn to_enum_variant_def (&self) -> TokenStream2 {
|
|
let mut out = TokenStream2::new();
|
|
out.append(self.to_enum_variant_ident());
|
|
let ident = &self.0;
|
|
if self.has_args() {
|
|
out.append(Group::new(Delimiter::Brace, {
|
|
let mut out = TokenStream2::new();
|
|
for (arg, ty) in self.args() {
|
|
write_quote_to(&mut out, quote! { #arg : #ty , });
|
|
}
|
|
out
|
|
}));
|
|
}
|
|
out.append(Punct::new(',', Alone));
|
|
out
|
|
}
|
|
fn to_enum_variant_bind (&self) -> TokenStream2 {
|
|
let mut out = TokenStream2::new();
|
|
out.append(self.to_enum_variant_ident());
|
|
let ident = &self.0;
|
|
if self.has_args() {
|
|
out.append(Group::new(Delimiter::Brace, {
|
|
let mut out = TokenStream2::new();
|
|
for (arg, ty) in self.args() {
|
|
let take_err = LitStr::new(&format!("{}: missing argument \"{}\" ({})",
|
|
quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
|
|
let give_err = LitStr::new(&format!("{}: missing value \"{}\" ({})",
|
|
quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
|
|
write_quote_to(&mut out, quote! {
|
|
#arg : Context::get(state, &iter.next().expect(#take_err).value)
|
|
.expect(#give_err) ,
|
|
});
|
|
}
|
|
out
|
|
}));
|
|
}
|
|
out
|
|
}
|
|
fn to_enum_variant_unbind (&self) -> TokenStream2 {
|
|
let mut out = TokenStream2::new();
|
|
out.append(self.to_enum_variant_ident());
|
|
let ident = &self.0;
|
|
if self.has_args() {
|
|
out.append(Group::new(Delimiter::Brace, {
|
|
let mut out = TokenStream2::new();
|
|
for (arg, ty) in self.args() {
|
|
write_quote_to(&mut out, quote! { #arg , });
|
|
}
|
|
out
|
|
}));
|
|
}
|
|
out
|
|
}
|
|
fn to_matcher (&self) -> TokenStream2 {
|
|
let key = LitStr::new(&self.to_key(), Span::call_site());
|
|
let variant = self.to_enum_variant_bind();
|
|
let pattern = quote! {
|
|
Some(::tengri::dsl::Token { value: ::tengri::dsl::Value::Key(#key), .. })
|
|
};
|
|
write_quote(quote! {
|
|
#pattern => { let mut iter = iter.clone(); Some(Self::#variant) },
|
|
})
|
|
}
|
|
fn to_implementation (&self) -> TokenStream2 {
|
|
let ident = &self.0;
|
|
let variant = self.to_enum_variant_unbind();
|
|
let mut give_rest = write_quote(quote! { /*TODO*/ });
|
|
let give_args = self.args().map(|(arg, ty)|write_quote(quote! { #arg, })).collect::<Vec<_>>();
|
|
write_quote(quote! { Self::#variant => Self::#ident(state, #(#give_args)* #give_rest), })
|
|
}
|
|
}
|
|
|
|
impl ToTokens for CommandVariant {
|
|
fn to_tokens (&self, out: &mut TokenStream2) {
|
|
let Self(ident, args) = self;
|
|
out.append(LitStr::new(&format!("{}", ident), Span::call_site())
|
|
.token());
|
|
out.append(Group::new(Delimiter::Parenthesis, {
|
|
let mut out = TokenStream2::new();
|
|
for arg in args.iter() {
|
|
if let FnArg::Typed(PatType { ty, .. }) = arg {
|
|
out.append(LitStr::new(
|
|
&format!("{}", quote! { #ty }),
|
|
Span::call_site()
|
|
).token());
|
|
out.append(Punct::new(',', Alone));
|
|
}
|
|
}
|
|
out
|
|
}));
|
|
out.append(Punct::new(',', Alone));
|
|
}
|
|
}
|
|
|
|
impl ToTokens for CommandArm {
|
|
fn to_tokens (&self, out: &mut TokenStream2) {
|
|
let Self(ident, args, returnType) = self;
|
|
for ident in ["tengri", "dsl", "Value", "Sym"].iter() {
|
|
out.append(Punct::new(':', Joint));
|
|
out.append(Punct::new(':', Alone));
|
|
out.append(Ident::new(ident, Span::call_site()));
|
|
}
|
|
out.append(Group::new(Delimiter::Parenthesis, {
|
|
let mut out = TokenStream2::new();
|
|
out.append(self.to_enum_variant_ident());
|
|
for arg in args.iter() {
|
|
}
|
|
out
|
|
}));
|
|
out.append(Punct::new('=', Joint));
|
|
out.append(Punct::new('>', Alone));
|
|
out.append(Ident::new("Self", Span::call_site()));
|
|
out.append(Punct::new(':', Joint));
|
|
out.append(Punct::new(':', Alone));
|
|
out.append(ident.clone());
|
|
out.append(Group::new(Delimiter::Parenthesis, {
|
|
let mut out = TokenStream2::new();
|
|
for arg in args.iter() {
|
|
// TODO
|
|
out.append(LitStr::new(&self.to_key(), Span::call_site()).token());
|
|
out.append(Punct::new(',', Alone));
|
|
}
|
|
out
|
|
}));
|
|
out.append(Punct::new(',', Alone));
|
|
}
|
|
}
|