dan/mangui
1
0
Fork 0
mirror of https://github.com/danbulant/mangui synced 2026-07-05 19:00:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix warnings

Browse source
This commit is contained in:
Daniel Bulant 2024-02-26 21:37:21 +01:00
parent 5f70fa3f7f
commit 93ac53a2e6
1 changed files with 116 additions and 139 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

255
rusalka-macro/src/lib.rs
View file

@ -1,7 +1,7 @@
use proc_macro2::{Ident, TokenStream, TokenTree, Span, Group, Delimiter}; use proc_macro2::{Ident, TokenStream, TokenTree, Span, Group, Delimiter};
use std::collections::HashMap; use std::collections::HashMap;
use quote::{format_ident, quote, ToTokens}; use quote::{format_ident, quote};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
struct Attribute { struct Attribute {
@ -124,7 +124,7 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
let mut last_was_set = false; let mut last_was_set = false;
let mut ltgt_count = 0; let mut ltgt_count = 0;
while let Some(token) = stream.next() { for token in stream.by_ref() {
match token { match token {
TokenTree::Ident(ident) => { TokenTree::Ident(ident) => {
type_.extend(Some(TokenTree::Ident(ident))); type_.extend(Some(TokenTree::Ident(ident)));
@ -163,7 +163,7 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
if last_was_set { if last_was_set {
let mut default = TokenStream::new(); let mut default = TokenStream::new();
while let Some(token) = stream.next() { for token in stream.by_ref() {
match token { match token {
TokenTree::Ident(ident) => { TokenTree::Ident(ident) => {
default.extend(Some(TokenTree::Ident(ident))); default.extend(Some(TokenTree::Ident(ident)));
@ -330,7 +330,7 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
component_struct_stream.extend(quote!(attrs: )); component_struct_stream.extend(quote!(attrs: ));
component_struct_stream.extend(Some(TokenTree::Ident(reactive_attributes_ident.clone()))); component_struct_stream.extend(Some(TokenTree::Ident(reactive_attributes_ident.clone())));
let component_struct_group = Group::new(proc_macro2::Delimiter::Brace, component_struct_stream); let component_struct_group = Group::new(Delimiter::Brace, component_struct_stream);
output.extend(Some(TokenTree::Group(component_struct_group))); output.extend(Some(TokenTree::Group(component_struct_group)));
@ -348,69 +348,69 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
attributes_struct_stream.extend(quote!(,)); attributes_struct_stream.extend(quote!(,));
} }
output.extend(Some(TokenTree::Group(Group::new(proc_macro2::Delimiter::Brace, attributes_struct_stream)))); output.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, attributes_struct_stream))));
// partial attributes // partial attributes
output.extend(TokenStream::from(quote!(#[derive(Default)] pub struct))); output.extend(quote!(#[derive(Default)] pub struct));
output.extend(Some(TokenTree::Ident(partial_attributes_ident.clone()))); output.extend(Some(TokenTree::Ident(partial_attributes_ident.clone())));
let mut attributes_default_struct_stream = TokenStream::new(); let mut attributes_default_struct_stream = TokenStream::new();
for attribute in &attributes { for attribute in &attributes {
attributes_default_struct_stream.extend(TokenStream::from(quote!(pub))); attributes_default_struct_stream.extend(quote!(pub));
attributes_default_struct_stream.extend(Some(TokenTree::Ident(attribute.name.clone()))); attributes_default_struct_stream.extend(Some(TokenTree::Ident(attribute.name.clone())));
attributes_default_struct_stream.extend(TokenStream::from(quote!(: Option<))); attributes_default_struct_stream.extend(quote!(: Option<));
attributes_default_struct_stream.extend(attribute.type_.clone()); attributes_default_struct_stream.extend(attribute.type_.clone());
attributes_default_struct_stream.extend(TokenStream::from(quote!(>,))); attributes_default_struct_stream.extend(quote!(>,));
} }
output.extend(Some(TokenTree::Group(Group::new(proc_macro2::Delimiter::Brace, attributes_default_struct_stream)))); output.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, attributes_default_struct_stream))));
// reactive attributes // reactive attributes
output.extend(TokenStream::from(quote!(#[derive(Default)] pub struct))); output.extend(quote!(#[derive(Default)] pub struct));
output.extend(Some(TokenTree::Ident(reactive_attributes_ident.clone()))); output.extend(Some(TokenTree::Ident(reactive_attributes_ident.clone())));
let mut attributes_default_struct_stream = TokenStream::new(); let mut attributes_default_struct_stream = TokenStream::new();
for attribute in &attributes { for attribute in &attributes {
attributes_default_struct_stream.extend(TokenStream::from(quote!(pub))); attributes_default_struct_stream.extend(quote!(pub));
attributes_default_struct_stream.extend(Some(TokenTree::Ident(attribute.name.clone()))); attributes_default_struct_stream.extend(Some(TokenTree::Ident(attribute.name.clone())));
attributes_default_struct_stream.extend(TokenStream::from(quote!(: std::sync::Arc<rusalka::store::Writable<))); attributes_default_struct_stream.extend(quote!(: std::sync::Arc<rusalka::store::Writable<));
attributes_default_struct_stream.extend(attribute.type_.clone()); attributes_default_struct_stream.extend(attribute.type_.clone());
attributes_default_struct_stream.extend(TokenStream::from(quote!(>>,))); attributes_default_struct_stream.extend(quote!(>>,));
} }
output.extend(Some(TokenTree::Group(Group::new(proc_macro2::Delimiter::Brace, attributes_default_struct_stream)))); output.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, attributes_default_struct_stream))));
// impl From<Attributes> for PartialAttributes // impl From<Attributes> for PartialAttributes
output.extend(TokenStream::from(quote!(impl From<))); output.extend(quote!(impl From<));
output.extend(Some(TokenTree::Ident(attributes_ident.clone()))); output.extend(Some(TokenTree::Ident(attributes_ident.clone())));
output.extend(TokenStream::from(quote!(> for))); output.extend(quote!(> for));
output.extend(Some(TokenTree::Ident(partial_attributes_ident.clone()))); output.extend(Some(TokenTree::Ident(partial_attributes_ident.clone())));
let mut from_stream = TokenStream::new(); let mut from_stream = TokenStream::new();
from_stream.extend(TokenStream::from(quote!(fn from))); from_stream.extend(quote!(fn from));
let mut from_args = TokenStream::new(); let mut from_args = TokenStream::new();
from_args.extend(TokenStream::from(quote!(attrs:))); from_args.extend(quote!(attrs:));
from_args.extend(Some(TokenTree::Ident(attributes_ident.clone()))); from_args.extend(Some(TokenTree::Ident(attributes_ident.clone())));
from_stream.extend(Some(TokenTree::Group(Group::new(proc_macro2::Delimiter::Parenthesis, from_args)))); from_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, from_args))));
from_stream.extend(TokenStream::from(quote!(-> Self))); from_stream.extend(quote!(-> Self));
let mut from_fn_stream = TokenStream::from(quote!(Self)); let mut from_fn_stream = quote!(Self);
let mut from_fn_stream_inner = TokenStream::new(); let mut from_fn_stream_inner = TokenStream::new();
for attribute in &attributes { for attribute in &attributes {
from_fn_stream_inner.extend(Some(TokenTree::Ident(attribute.name.clone()))); from_fn_stream_inner.extend(Some(TokenTree::Ident(attribute.name.clone())));
from_fn_stream_inner.extend(TokenStream::from(quote!(:))); from_fn_stream_inner.extend(quote!(:));
from_fn_stream_inner.extend(TokenStream::from(quote!(Some))); from_fn_stream_inner.extend(quote!(Some));
let mut from_fn_stream_inner_inner = TokenStream::new(); let mut from_fn_stream_inner_inner = TokenStream::new();
from_fn_stream_inner_inner.extend(TokenStream::from(quote!(attrs.))); from_fn_stream_inner_inner.extend(quote!(attrs.));
from_fn_stream_inner_inner.extend(Some(TokenTree::Ident(attribute.name.clone()))); from_fn_stream_inner_inner.extend(Some(TokenTree::Ident(attribute.name.clone())));
from_fn_stream_inner.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, from_fn_stream_inner_inner)))); from_fn_stream_inner.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, from_fn_stream_inner_inner))));
@ -423,30 +423,30 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
// impl From<Attributes> for ReactiveAttributes // impl From<Attributes> for ReactiveAttributes
output.extend(TokenStream::from(quote!(impl From<))); output.extend(quote!(impl From<));
output.extend(Some(TokenTree::Ident(attributes_ident.clone()))); output.extend(Some(TokenTree::Ident(attributes_ident.clone())));
output.extend(TokenStream::from(quote!(> for))); output.extend(quote!(> for));
output.extend(Some(TokenTree::Ident(reactive_attributes_ident.clone()))); output.extend(Some(TokenTree::Ident(reactive_attributes_ident.clone())));
let mut from_stream = TokenStream::new(); let mut from_stream = TokenStream::new();
from_stream.extend(TokenStream::from(quote!(fn from))); from_stream.extend(quote!(fn from));
let mut from_args = TokenStream::new(); let mut from_args = TokenStream::new();
from_args.extend(TokenStream::from(quote!(attrs:))); from_args.extend(quote!(attrs:));
from_args.extend(Some(TokenTree::Ident(attributes_ident.clone()))); from_args.extend(Some(TokenTree::Ident(attributes_ident.clone())));
from_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, from_args)))); from_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, from_args))));
from_stream.extend(TokenStream::from(quote!(-> Self))); from_stream.extend(quote!(-> Self));
let mut from_fn_stream = TokenStream::from(quote!(Self)); let mut from_fn_stream = quote!(Self);
let mut from_fn_stream_inner = TokenStream::new(); let mut from_fn_stream_inner = TokenStream::new();
for attribute in &attributes { for attribute in &attributes {
let name = attribute.name.clone(); let name = attribute.name.clone();
from_fn_stream_inner.extend(TokenStream::from(quote!( from_fn_stream_inner.extend(quote!(
#name : std::sync::Arc::new(rusalka::store::Writable::new(attrs.#name)) #name : std::sync::Arc::new(rusalka::store::Writable::new(attrs.#name))
))); ));
} }
from_fn_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, from_fn_stream_inner)))); from_fn_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, from_fn_stream_inner))));
@ -456,33 +456,33 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
// Component impl // Component impl
output.extend(TokenStream::from(quote!(impl rusalka::component::Component for #name_ident))); output.extend(quote!(impl rusalka::component::Component for #name_ident));
let mut component_impl_stream = TokenStream::new(); let mut component_impl_stream = TokenStream::new();
component_impl_stream.extend(TokenStream::from(quote!( component_impl_stream.extend(quote!(
type ComponentAttrs = #attributes_ident; type ComponentAttrs = #attributes_ident;
type PartialComponentAttrs = #partial_attributes_ident; type PartialComponentAttrs = #partial_attributes_ident;
type ReactiveComponentAttrs = #reactive_attributes_ident; type ReactiveComponentAttrs = #reactive_attributes_ident;
))); ));
// fn new // fn new
component_impl_stream.extend(TokenStream::from(quote!( component_impl_stream.extend(quote!(
fn new(attrs: Self::ComponentAttrs, selfref: rusalka::WeakSharedComponent<Self>) -> Self fn new(attrs: Self::ComponentAttrs, selfref: rusalka::WeakSharedComponent<Self>) -> Self
))); ));
let mut new_stream = TokenStream::new(); let mut new_stream = TokenStream::new();
new_stream.extend(TokenStream::from(quote!( new_stream.extend(quote!(
let attrs: Self::ReactiveComponentAttrs = attrs.into(); let attrs: Self::ReactiveComponentAttrs = attrs.into();
))); ));
for attribute in &attributes { for attribute in &attributes {
let name = attribute.name.clone(); let name = attribute.name.clone();
new_stream.extend(TokenStream::from(quote!( new_stream.extend(quote!(
let #name = attrs.#name.clone(); let #name = attrs.#name.clone();
))); ));
} }
for variable in &reactive_variables { for variable in &reactive_variables {
@ -492,27 +492,26 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
if let Some(def) = &variable.default { if let Some(def) = &variable.default {
invalidator_inner.extend(replace_variables(def.clone()).1); invalidator_inner.extend(replace_variables(def.clone()).1);
} else { } else {
invalidator_inner.extend(TokenStream::from(quote!(Default::default()))); invalidator_inner.extend(quote!(Default::default()));
} }
new_stream.extend(TokenStream::from(quote!( new_stream.extend(quote!(
let #name : std::sync::Arc<rusalka::store::Writable< #type_ >> = let #name : std::sync::Arc<rusalka::store::Writable< #type_ >> =
std::sync::Arc::new(rusalka::store::Writable::new( #invalidator_inner )); std::sync::Arc::new(rusalka::store::Writable::new( #invalidator_inner ));
))); ));
} }
new_stream.extend(main_logic); new_stream.extend(main_logic);
new_stream.extend(TokenStream::from(quote!(let this = Self))); new_stream.extend(quote!(let this = Self));
let mut new_returnvalue_stream = TokenStream::new(); let mut new_returnvalue_stream = TokenStream::new();
let mut i = 0; for (i, component) in components_used.iter().enumerate() {
for component in &components_used {
let ident = Ident::new(&format!("comp{}", i), component.name.span()); let ident = Ident::new(&format!("comp{}", i), component.name.span());
let component_name = component.name.clone(); let component_name = component.name.clone();
new_returnvalue_stream.extend(Some(TokenTree::Ident(ident))); new_returnvalue_stream.extend(Some(TokenTree::Ident(ident)));
new_returnvalue_stream.extend(TokenStream::from(quote!(:))); new_returnvalue_stream.extend(quote!(:));
let mut component_stream = TokenStream::new(); let mut component_stream = TokenStream::new();
@ -520,7 +519,7 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
match component.component_type { match component.component_type {
ComponentType::RealComponent => { ComponentType::RealComponent => {
component_stream.extend(TokenStream::from(quote!(::new))); component_stream.extend(quote!(::new));
let mut component_new_stream = TokenStream::new(); let mut component_new_stream = TokenStream::new();
@ -536,7 +535,7 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
component_new_stream.extend(Some(TokenTree::Group(components_attributes_group))); component_new_stream.extend(Some(TokenTree::Group(components_attributes_group)));
component_new_stream.extend(TokenStream::from(quote!(, cselfref.clone()))); component_new_stream.extend(quote!(, cselfref.clone()));
let component_new_group = Group::new(Delimiter::Parenthesis, component_new_stream); let component_new_group = Group::new(Delimiter::Parenthesis, component_new_stream);
@ -552,8 +551,6 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
} }
} }
new_returnvalue_stream.extend(quote!(,)); new_returnvalue_stream.extend(quote!(,));
i+=1;
} }
new_returnvalue_stream.extend(quote!(attrs, selfref, sub: vec!)); new_returnvalue_stream.extend(quote!(attrs, selfref, sub: vec!));
@ -600,37 +597,37 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
ComponentType::Node => {} ComponentType::Node => {}
}; };
for event_listener in &component.event_listeners { for event_listener in &component.event_listeners {
new_stream.extend(TokenStream::from(quote!(let selfref = this.selfref.clone();))); new_stream.extend(quote!(let selfref = this.selfref.clone();));
new_stream.extend(TokenStream::from(quote!(this.))); new_stream.extend(quote!(this.));
new_stream.extend(Some(TokenTree::Ident(Ident::new(&format!("comp{}", i), component.name.span())))); new_stream.extend(Some(TokenTree::Ident(Ident::new(&format!("comp{}", i), component.name.span()))));
// Change the following line according to how realcomponents want it - this is for nodes only // Change the following line according to how realcomponents want it - this is for nodes only
new_stream.extend(TokenStream::from(quote!(.write().unwrap().events.add_handler))); new_stream.extend(quote!(.write().unwrap().events.add_handler));
let mut box_stream = TokenStream::new(); let mut box_stream = TokenStream::new();
box_stream.extend(TokenStream::from(quote!(Box::new))); box_stream.extend(quote!(Box::new));
let mut callback_stream = TokenStream::new(); let mut callback_stream = TokenStream::new();
callback_stream.extend(TokenStream::from(quote!(move |))); callback_stream.extend(quote!(move |));
callback_stream.extend(Some(TokenTree::Ident(event_listener.identifier.clone()))); callback_stream.extend(Some(TokenTree::Ident(event_listener.identifier.clone())));
callback_stream.extend(TokenStream::from(quote!(|))); callback_stream.extend(quote!(|));
let mut inner_callback_stream = TokenStream::new(); let mut inner_callback_stream = TokenStream::new();
inner_callback_stream.extend(TokenStream::from(quote!( inner_callback_stream.extend(quote!(
let selfref = selfref.upgrade().unwrap(); let selfref = selfref.upgrade().unwrap();
let mut this = selfref.lock().unwrap(); let mut this = selfref.lock().unwrap();
let attrs = &this.attrs; let attrs = &this.attrs;
))); ));
for variable in &reactive_variables { for variable in &reactive_variables {
inner_callback_stream.extend(TokenStream::from(quote!(let))); inner_callback_stream.extend(quote!(let));
inner_callback_stream.extend(Some(TokenTree::Ident(variable.name.clone()))); inner_callback_stream.extend(Some(TokenTree::Ident(variable.name.clone())));
inner_callback_stream.extend(TokenStream::from(quote!(= &this.))); inner_callback_stream.extend(quote!(= &this.));
inner_callback_stream.extend(Some(TokenTree::Ident(variable.name.clone()))); inner_callback_stream.extend(Some(TokenTree::Ident(variable.name.clone())));
inner_callback_stream.extend(TokenStream::from(quote!(;))); inner_callback_stream.extend(quote!(;));
} }
inner_callback_stream.extend(replace_variables(event_listener.callback.clone().stream()).1); inner_callback_stream.extend(replace_variables(event_listener.callback.clone().stream()).1);
@ -647,45 +644,45 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
new_stream.extend(Some(TokenTree::Group(box_group))); new_stream.extend(Some(TokenTree::Group(box_group)));
new_stream.extend(TokenStream::from(quote!(;))); new_stream.extend(quote!(;));
} }
i += 1; i += 1;
} }
new_stream.extend(TokenStream::from(quote!(this))); new_stream.extend(quote!(this));
let new_group = Group::new(Delimiter::Brace, new_stream); let new_group = Group::new(Delimiter::Brace, new_stream);
component_impl_stream.extend(Some(TokenTree::Group(new_group))); component_impl_stream.extend(Some(TokenTree::Group(new_group)));
// fn set // fn set
component_impl_stream.extend(TokenStream::from(quote!(fn set(&mut self, attrs: Self::PartialComponentAttrs)))); component_impl_stream.extend(quote!(fn set(&mut self, attrs: Self::PartialComponentAttrs)));
let mut set_stream = TokenStream::new(); let mut set_stream = TokenStream::new();
if attributes.len() > 0 { if !attributes.is_empty() {
for (i, attribute) in attributes.iter().enumerate() { for (_i, attribute) in attributes.iter().enumerate() {
set_stream.extend(TokenStream::from(quote!(if let Some))); set_stream.extend(quote!(if let Some));
let mut some_inner = TokenStream::new(); let mut some_inner = TokenStream::new();
some_inner.extend(Some(TokenTree::Ident(attribute.name.clone()))); some_inner.extend(Some(TokenTree::Ident(attribute.name.clone())));
set_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, some_inner)))); set_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, some_inner))));
set_stream.extend(TokenStream::from(quote!(= attrs.))); set_stream.extend(quote!(= attrs.));
set_stream.extend(Some(TokenTree::Ident(attribute.name.clone()))); set_stream.extend(Some(TokenTree::Ident(attribute.name.clone())));
let mut set_stream_inner = TokenStream::new(); let mut set_stream_inner = TokenStream::new();
set_stream_inner.extend(TokenStream::from(quote!(self.attrs.))); set_stream_inner.extend(quote!(self.attrs.));
set_stream_inner.extend(Some(TokenTree::Ident(attribute.name.clone()))); set_stream_inner.extend(Some(TokenTree::Ident(attribute.name.clone())));
set_stream_inner.extend(TokenStream::from(quote!(.set))); set_stream_inner.extend(quote!(.set));
let mut set_stream_inner_inner = TokenStream::new(); let mut set_stream_inner_inner = TokenStream::new();
set_stream_inner_inner.extend(Some(TokenTree::Ident(attribute.name.clone()))); set_stream_inner_inner.extend(Some(TokenTree::Ident(attribute.name.clone())));
set_stream_inner.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, set_stream_inner_inner)))); set_stream_inner.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, set_stream_inner_inner))));
set_stream_inner.extend(TokenStream::from(quote!(;))); set_stream_inner.extend(quote!(;));
set_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, set_stream_inner)))); set_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, set_stream_inner))));
} }
@ -696,11 +693,11 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
// fn get // fn get
component_impl_stream.extend(TokenStream::from(quote!(fn get(&self) -> &Self::ReactiveComponentAttrs { &self.attrs }))); component_impl_stream.extend(quote!(fn get(&self) -> &Self::ReactiveComponentAttrs { &self.attrs }));
// fn mount // fn mount
component_impl_stream.extend(TokenStream::from(quote!(fn mount(&self, parent: &mangui::SharedNode, before: Option<&mangui::SharedNode>)))); component_impl_stream.extend(quote!(fn mount(&self, parent: &mangui::SharedNode, before: Option<&mangui::SharedNode>)));
let mut mount_stream = TokenStream::new(); let mut mount_stream = TokenStream::new();
@ -711,9 +708,9 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
match component.component_type { match component.component_type {
ComponentType::RealComponent => { ComponentType::RealComponent => {
// mount // mount
mount_stream.extend(TokenStream::from(quote!(self.))); mount_stream.extend(quote!(self.));
mount_stream.extend(Some(TokenTree::Ident(ident))); mount_stream.extend(Some(TokenTree::Ident(ident)));
mount_stream.extend(TokenStream::from(quote!(.lock().unwrap().mount))); mount_stream.extend(quote!(.lock().unwrap().mount));
let mut component_mount_stream = TokenStream::new(); let mut component_mount_stream = TokenStream::new();
@ -723,31 +720,31 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
let mut node_insert_self_stream = TokenStream::new(); let mut node_insert_self_stream = TokenStream::new();
node_insert_self_stream.extend(TokenStream::from(quote!(self.))); node_insert_self_stream.extend(quote!(self.));
node_insert_self_stream.extend(Some(TokenTree::Ident(parent_ident))); node_insert_self_stream.extend(Some(TokenTree::Ident(parent_ident)));
node_insert_self_stream.extend(TokenStream::from(quote!(.clone()))); node_insert_self_stream.extend(quote!(.clone()));
let node_insert_self_group = Group::new(Delimiter::Brace, node_insert_self_stream); let node_insert_self_group = Group::new(Delimiter::Brace, node_insert_self_stream);
component_mount_stream.extend(TokenStream::from(quote!(&))); component_mount_stream.extend(quote!(&));
component_mount_stream.extend(Some(TokenTree::Group(node_insert_self_group))); component_mount_stream.extend(Some(TokenTree::Group(node_insert_self_group)));
}, },
None => { None => {
component_mount_stream.extend(TokenStream::from(quote!(parent))); component_mount_stream.extend(quote!(parent));
} }
} }
component_mount_stream.extend(TokenStream::from(quote!(,))); component_mount_stream.extend(quote!(,));
component_mount_stream.extend(TokenStream::from(quote!(before))); component_mount_stream.extend(quote!(before));
let component_mount_group = Group::new(Delimiter::Parenthesis, component_mount_stream); let component_mount_group = Group::new(Delimiter::Parenthesis, component_mount_stream);
mount_stream.extend(Some(TokenTree::Group(component_mount_group))); mount_stream.extend(Some(TokenTree::Group(component_mount_group)));
mount_stream.extend(TokenStream::from(quote!(;))); mount_stream.extend(quote!(;));
}, },
ComponentType::Node => { ComponentType::Node => {
let mut node_stream = TokenStream::new(); let mut node_stream = TokenStream::new();
node_stream.extend(TokenStream::from(quote!(rusalka::nodes::insert))); node_stream.extend(quote!(rusalka::nodes::insert));
let mut node_insert_stream = TokenStream::new(); let mut node_insert_stream = TokenStream::new();
@ -757,38 +754,38 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
let mut node_insert_self_stream = TokenStream::new(); let mut node_insert_self_stream = TokenStream::new();
node_insert_self_stream.extend(TokenStream::from(quote!(self.))); node_insert_self_stream.extend(quote!(self.));
node_insert_self_stream.extend(Some(TokenTree::Ident(parent_ident))); node_insert_self_stream.extend(Some(TokenTree::Ident(parent_ident)));
node_insert_self_stream.extend(TokenStream::from(quote!(.clone()))); node_insert_self_stream.extend(quote!(.clone()));
let node_insert_self_group = Group::new(Delimiter::Brace, node_insert_self_stream); let node_insert_self_group = Group::new(Delimiter::Brace, node_insert_self_stream);
node_insert_stream.extend(TokenStream::from(quote!(&))); node_insert_stream.extend(quote!(&));
node_insert_stream.extend(Some(TokenTree::Group(node_insert_self_group))); node_insert_stream.extend(Some(TokenTree::Group(node_insert_self_group)));
}, },
None => { None => {
node_insert_stream.extend(TokenStream::from(quote!(parent))); node_insert_stream.extend(quote!(parent));
} }
} }
node_insert_stream.extend(TokenStream::from(quote!(,))); node_insert_stream.extend(quote!(,));
node_insert_stream.extend(TokenStream::from(quote!(&))); node_insert_stream.extend(quote!(&));
let mut node_insert_self_stream = TokenStream::new(); let mut node_insert_self_stream = TokenStream::new();
node_insert_self_stream.extend(TokenStream::from(quote!(self.))); node_insert_self_stream.extend(quote!(self.));
node_insert_self_stream.extend(Some(TokenTree::Ident(ident))); node_insert_self_stream.extend(Some(TokenTree::Ident(ident)));
node_insert_self_stream.extend(TokenStream::from(quote!(.clone()))); node_insert_self_stream.extend(quote!(.clone()));
let node_insert_self_group = Group::new(Delimiter::Brace, node_insert_self_stream); let node_insert_self_group = Group::new(Delimiter::Brace, node_insert_self_stream);
node_insert_stream.extend(Some(TokenTree::Group(node_insert_self_group))); node_insert_stream.extend(Some(TokenTree::Group(node_insert_self_group)));
node_insert_stream.extend(TokenStream::from(quote!(,))); node_insert_stream.extend(quote!(,));
node_insert_stream.extend(TokenStream::from(quote!(before))); node_insert_stream.extend(quote!(before));
node_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, node_insert_stream)))); node_stream.extend(Some(TokenTree::Group(Group::new(Delimiter::Parenthesis, node_insert_stream))));
mount_stream.extend(node_stream); mount_stream.extend(node_stream);
mount_stream.extend(TokenStream::from(quote!(;))); mount_stream.extend(quote!(;));
} }
} }
@ -799,7 +796,7 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
// fn unmount // fn unmount
component_impl_stream.extend(TokenStream::from(quote!(fn unmount(&self)))); component_impl_stream.extend(quote!(fn unmount(&self)));
let mut unmount_stream = TokenStream::new(); let mut unmount_stream = TokenStream::new();
@ -811,31 +808,31 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
ComponentType::RealComponent => { ComponentType::RealComponent => {
let mut component_stream = TokenStream::new(); let mut component_stream = TokenStream::new();
component_stream.extend(TokenStream::from(quote!(self.))); component_stream.extend(quote!(self.));
component_stream.extend(Some(TokenTree::Ident(ident))); component_stream.extend(Some(TokenTree::Ident(ident)));
component_stream.extend(TokenStream::from(quote!(.lock().unwrap().unmount()))); component_stream.extend(quote!(.lock().unwrap().unmount()));
unmount_stream.extend(component_stream); unmount_stream.extend(component_stream);
unmount_stream.extend(TokenStream::from(quote!(;))); unmount_stream.extend(quote!(;));
}, },
ComponentType::Node => { ComponentType::Node => {
unmount_stream.extend(TokenStream::from(quote!(rusalka::nodes::detach))); unmount_stream.extend(quote!(rusalka::nodes::detach));
let mut node_detach_stream = TokenStream::new(); let mut node_detach_stream = TokenStream::new();
node_detach_stream.extend(TokenStream::from(quote!(&))); node_detach_stream.extend(quote!(&));
let mut node_detach_self_stream = TokenStream::new(); let mut node_detach_self_stream = TokenStream::new();
node_detach_self_stream.extend(TokenStream::from(quote!(self.))); node_detach_self_stream.extend(quote!(self.));
node_detach_self_stream.extend(Some(TokenTree::Ident(ident))); node_detach_self_stream.extend(Some(TokenTree::Ident(ident)));
node_detach_self_stream.extend(TokenStream::from(quote!(.clone()))); node_detach_self_stream.extend(quote!(.clone()));
let node_detach_self_group = Group::new(Delimiter::Brace, node_detach_self_stream); let node_detach_self_group = Group::new(Delimiter::Brace, node_detach_self_stream);
node_detach_stream.extend(Some(TokenTree::Group(node_detach_self_group))); node_detach_stream.extend(Some(TokenTree::Group(node_detach_self_group)));
let node_detach_group = Group::new(Delimiter::Parenthesis, node_detach_stream); let node_detach_group = Group::new(Delimiter::Parenthesis, node_detach_stream);
unmount_stream.extend(Some(TokenTree::Group(node_detach_group))); unmount_stream.extend(Some(TokenTree::Group(node_detach_group)));
unmount_stream.extend(TokenStream::from(quote!(;))); unmount_stream.extend(quote!(;));
} }
} }
} }
@ -845,7 +842,7 @@ pub fn make_component(item: proc_macro::TokenStream) -> proc_macro::TokenStream
output.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, component_impl_stream)))); output.extend(Some(TokenTree::Group(Group::new(Delimiter::Brace, component_impl_stream))));
println!("{}", output.to_string()); println!("{}", output);
println!(); println!();
@ -870,9 +867,9 @@ fn replace_variables(stream: TokenStream) -> (Vec<Ident>, TokenStream) {
_ => panic!("Expected ident after $") _ => panic!("Expected ident after $")
}; };
idents.push(ident.clone()); idents.push(ident.clone());
output.extend(TokenStream::from(quote!(**))); output.extend(quote!(**));
output.extend(Some(TokenTree::Ident(ident.clone()))); output.extend(Some(TokenTree::Ident(ident.clone())));
output.extend(TokenStream::from(quote!(.guard()))); output.extend(quote!(.guard()));
}, },
TokenTree::Group(group) => { TokenTree::Group(group) => {
let group_delim = group.delimiter(); let group_delim = group.delimiter();
@ -889,44 +886,24 @@ fn replace_variables(stream: TokenStream) -> (Vec<Ident>, TokenStream) {
} }
} }
idents.sort_by(|a, b| a.to_string().cmp(&b.to_string())); idents.sort_by_key(|a| a.to_string());
idents.dedup_by(|a, b| a.to_string() == b.to_string()); idents.dedup_by(|a, b| *b == a.to_string());
(idents, output) (idents, output)
} }
fn wrap_in_arc_mutex(stream: TokenStream) -> TokenStream {
let mut output = TokenStream::new();
output.extend(TokenStream::from(quote!(std::sync::Arc::new)));
let mutex_group = Group::new(Delimiter::Parenthesis, stream);
let mut mutex_stream = TokenStream::new();
mutex_stream.extend(TokenStream::from(quote!(std::sync::Mutex::new)));
mutex_stream.extend(Some(TokenTree::Group(mutex_group)));
let arc_group = Group::new(Delimiter::Parenthesis, mutex_stream);
output.extend(Some(TokenTree::Group(arc_group)));
output
}
fn wrap_in_arcmutex_cyclic(stream: TokenStream) -> TokenStream { fn wrap_in_arcmutex_cyclic(stream: TokenStream) -> TokenStream {
let mut output = TokenStream::new(); let mut output = TokenStream::new();
output.extend(TokenStream::from(quote!(std::sync::Arc::new_cyclic))); output.extend(quote!(std::sync::Arc::new_cyclic));
let mutex_group = Group::new(Delimiter::Parenthesis, stream); let mutex_group = Group::new(Delimiter::Parenthesis, stream);
let mut mutex_stream = TokenStream::new(); let mut mutex_stream = TokenStream::new();
mutex_stream.extend(TokenStream::from(quote!(|cselfref|))); mutex_stream.extend(quote!(|cselfref|));
mutex_stream.extend(TokenStream::from(quote!(std::sync::Mutex::new))); mutex_stream.extend(quote!(std::sync::Mutex::new));
mutex_stream.extend(Some(TokenTree::Group(mutex_group))); mutex_stream.extend(Some(TokenTree::Group(mutex_group)));
@ -940,13 +917,13 @@ fn wrap_in_arcmutex_cyclic(stream: TokenStream) -> TokenStream {
fn wrap_in_arcrwlock(stream: TokenStream) -> TokenStream { fn wrap_in_arcrwlock(stream: TokenStream) -> TokenStream {
let mut output = TokenStream::new(); let mut output = TokenStream::new();
output.extend(TokenStream::from(quote!(std::sync::Arc::new))); output.extend(quote!(std::sync::Arc::new));
let mutex_group = Group::new(Delimiter::Parenthesis, stream); let mutex_group = Group::new(Delimiter::Parenthesis, stream);
let mut rwlock_stream = TokenStream::new(); let mut rwlock_stream = TokenStream::new();
rwlock_stream.extend(TokenStream::from(quote!(std::sync::RwLock::new))); rwlock_stream.extend(quote!(std::sync::RwLock::new));
rwlock_stream.extend(Some(TokenTree::Group(mutex_group))); rwlock_stream.extend(Some(TokenTree::Group(mutex_group)));
@ -1046,7 +1023,7 @@ fn parse_components(name: Ident, group: Group, next: usize, parent: Option<usize
self_stream.extend(Some(TokenTree::Punct(punct))); self_stream.extend(Some(TokenTree::Punct(punct)));
// likely reactive property // likely reactive property
let mut property_stream = TokenStream::new(); let mut property_stream = TokenStream::new();
while let Some(token) = group.next() { for token in group.by_ref() {
match token { match token {
TokenTree::Punct(punct) => { TokenTree::Punct(punct) => {
let char = punct.as_char(); let char = punct.as_char();
@ -1061,7 +1038,7 @@ fn parse_components(name: Ident, group: Group, next: usize, parent: Option<usize
} }
} }
let (reactive_variables, property_stream) = replace_variables(property_stream); let (reactive_variables, property_stream) = replace_variables(property_stream);
if reactive_variables.len() > 0 { if !reactive_variables.is_empty() {
let this_component = components_found.get_mut(0).unwrap(); let this_component = components_found.get_mut(0).unwrap();
this_component.reactive_props.insert(ident_str, ReactiveBlock { this_component.reactive_props.insert(ident_str, ReactiveBlock {
variables: reactive_variables, variables: reactive_variables,
@ -1080,7 +1057,7 @@ fn parse_components(name: Ident, group: Group, next: usize, parent: Option<usize
any => { any => {
// skip until next ',', writing to self_stream // skip until next ',', writing to self_stream
self_stream.extend(Some(any)); self_stream.extend(Some(any));
while let Some(token) = group.next() { for token in group.by_ref() {
match token { match token {
TokenTree::Punct(punct) => { TokenTree::Punct(punct) => {
let char = punct.as_char(); let char = punct.as_char();