unspeaker/tengri
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tengri.git synced 2025-12-06 03:36:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

proc, input, output: cleanup warnings

Browse source
This commit is contained in:
🪞👃🪞 2025-05-09 20:02:24 +03:00
parent ab07fd2b43
commit 60c0771024
6 changed files with 32 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

3
input/src/input_dsl.rs
View file

@ -132,8 +132,7 @@ where
M: KeyMap<'state, S, C, I> + Send + Sync
{
fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
write!(f, "[InputMap: {} layer(s)]", self.layers.len());
Ok(())
write!(f, "[InputMap: {} layer(s)]", self.layers.len())
}
}

48
output/src/ops/cond.rs
View file

@ -22,18 +22,13 @@ impl<A, B> Either<A, B> {
try_from_expr!(<'source, 'state, E>: When<RenderBox<'state, E>>: |state, iter| {
if let Some(Token { value: Value::Key("when"), .. }) = iter.peek() {
let _ = iter.next().unwrap();
let condition = iter.next().expect("no condition specified");
let condition = state.get(&mut iter).expect("no condition provided");
let content = iter.next().expect("no content specified");
let content = if let Some(content) = state.get_content(&content.value) {
content
} else {
panic!("no content corresponding to for {:?}", &content);
};
return Some(Self(condition, content))
let content = iter.next().expect("no content specified").value;
return Some(Self(
state.get(&mut iter)
.expect("no condition provided"),
state.get_content(&content)
.unwrap_or_else(||panic!("no content corresponding to for {:?}", &content))
))
}
});
@ -41,25 +36,16 @@ try_from_expr!(<'source, 'state, E>: When<RenderBox<'state, E>>: |state, iter| {
try_from_expr!(<'source, 'state, E>: Either<RenderBox<'state, E>, RenderBox<'state, E>>: |state, iter| {
if let Some(Token { value: Value::Key("either"), .. }) = iter.peek() {
let _ = iter.next().unwrap();
let condition = iter.next().expect("no condition specified");
let condition = state.get(&mut iter).expect("no condition provided");
let content = iter.next().expect("no content specified");
let content = if let Some(content) = state.get_content(&content.value) {
content
} else {
panic!("no content 1 corresponding to {:?}", &content);
};
let alternate = iter.next().expect("no alternate specified");
let alternate = if let Some(alternate) = state.get_content(&alternate.value) {
alternate
} else {
panic!("no content 2 corresponding to {:?}", &alternate);
};
return Some(Self(condition, content, alternate))
let content = iter.next().expect("no content specified").value;
let alternate = iter.next().expect("no alternate specified").value;
return Some(Self(
state.get(&mut iter)
.expect("no condition provided"),
state.get_content(&content)
.unwrap_or_else(||panic!("no content 1 corresponding to {:?}", &content)),
state.get_content(&alternate)
.unwrap_or_else(||panic!("no content 2 corresponding to {:?}", &alternate)),
))
}
});

14
proc/src/lib.rs
View file

@ -2,23 +2,17 @@
#![feature(box_patterns)]
extern crate proc_macro;
pub(crate) use std::collections::{BTreeMap, BTreeSet};
pub(crate) use std::collections::BTreeMap;
pub(crate) use std::cmp::Ordering;
pub(crate) use std::sync::Arc;
pub(crate) use proc_macro::TokenStream;
pub(crate) use proc_macro2::{
TokenStream as TokenStream2, TokenTree,
Ident, Span, Punct, Spacing::*, Group, Delimiter, Literal
TokenStream as TokenStream2, Ident, Span, Punct, Group, Delimiter, Spacing::*
};
pub(crate) use syn::{
parse, parse_macro_input, parse_quote as pq,
braced, bracketed, parenthesized, Token,
Arm, Expr, Attribute, Meta, MetaList, Path, PathSegment, PathArguments,
ImplItem, ImplItemFn, LitStr, Type, ItemImpl, ReturnType, Signature, FnArg,
Pat, PatType, PatIdent,
parse_macro_input, ImplItem, ImplItemFn, LitStr, Type,
ItemImpl, ReturnType, Signature, FnArg, Pat, PatType, PatIdent,
parse::{Parse, ParseStream, Result},
token::{PathSep, Brace},
punctuated::Punctuated,
};
pub(crate) use quote::{quote, TokenStreamExt, ToTokens};
pub(crate) use heck::{AsKebabCase, AsUpperCamelCase};

49
proc/src/proc_command.rs
View file

@ -121,13 +121,12 @@ impl CommandArm {
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;
//let ident = &self.0;
if self.has_args() {
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
@ -148,8 +147,8 @@ impl CommandArm {
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 take_err = LitStr::new(&format!("{}: missing argument \"{}\" ({})",
//quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
let give_err = LitStr::new(&format!("{}: missing value for \"{}\" ({})",
quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
write_quote_to(&mut out, quote! {
@ -164,11 +163,11 @@ impl CommandArm {
fn to_enum_variant_unbind (&self) -> TokenStream2 {
let mut out = TokenStream2::new();
out.append(self.to_enum_variant_ident());
let ident = &self.0;
//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() {
for (arg, _ty) in self.args() {
write_quote_to(&mut out, quote! { #arg , });
}
out
@ -189,8 +188,10 @@ impl CommandArm {
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<_>>();
let 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), })
}
}
@ -216,35 +217,3 @@ impl ToTokens for CommandVariant {
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());
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));
}
}

2
proc/src/proc_expose.rs
View file

@ -19,7 +19,7 @@ struct ExposeSym(LitStr);
struct ExposeType(Box<Type>);
impl Parse for ExposeMeta {
fn parse (input: ParseStream) -> Result<Self> {
fn parse (_input: ParseStream) -> Result<Self> {
Ok(Self)
}
}

9
proc/src/proc_view.rs
View file

@ -146,15 +146,6 @@ impl ToTokens for ViewArm {
//}
//}
fn nth_segment_is (segments: &Punctuated<PathSegment, PathSep>, n: usize, x: &str) -> bool {
if let Some(PathSegment { arguments: PathArguments::None, ident, .. }) = segments.get(n) {
if format!("{ident}") == x {
return true
}
}
return false
}
//impl std::cmp::PartialEq for ViewItem {
//fn eq (&self, other: &Self) -> bool {
//self.item == other.item && (format!("{:?}", self.expose) == format!("{:?}", other.expose))