pass clippy

packages/native-core-macro/src/lib.rs

@@ -21,9 +21,9 @@ pub fn sorted_str_slice(input: TokenStream) -> TokenStream {
 
 #[derive(PartialEq, Debug, Clone)]
 enum DepKind {
-    NodeDepState,
-    ChildDepState,
-    ParentDepState,
+    Node,
+    Child,
+    Parent,
 }
 
 #[proc_macro_derive(State, attributes(node_dep_state, child_dep_state, parent_dep_state))]
@@ -50,23 +50,23 @@ fn impl_derive_macro(ast: &syn::DeriveInput) -> TokenStream {
             let node_dep_state_fields = state_strct
                 .state_members
                 .iter()
-                .filter(|f| f.dep_kind == DepKind::NodeDepState)
+                .filter(|f| f.dep_kind == DepKind::Node)
                 .map(|f| f.reduce_self());
             let child_dep_state_fields = state_strct
                 .state_members
                 .iter()
-                .filter(|f| f.dep_kind == DepKind::ChildDepState)
+                .filter(|f| f.dep_kind == DepKind::Child)
                 .map(|f| f.reduce_self());
             let parent_dep_state_fields = state_strct
                 .state_members
                 .iter()
-                .filter(|f| f.dep_kind == DepKind::ParentDepState)
+                .filter(|f| f.dep_kind == DepKind::Parent)
                 .map(|f| f.reduce_self());
 
             let node_iter = state_strct
                 .state_members
                 .iter()
-                .filter(|m| m.dep_kind == DepKind::NodeDepState);
+                .filter(|m| m.dep_kind == DepKind::Node);
             let node_ids = node_iter.clone().map(|m| m.member_id.0);
             let node_ids_clone = node_ids.clone();
             let node_types = node_iter.map(|f| &f.mem.ty);
@@ -74,7 +74,7 @@ fn impl_derive_macro(ast: &syn::DeriveInput) -> TokenStream {
             let child_iter = state_strct
                 .state_members
                 .iter()
-                .filter(|m| m.dep_kind == DepKind::ChildDepState);
+                .filter(|m| m.dep_kind == DepKind::Child);
             let child_ids = child_iter.clone().map(|m| m.member_id.0);
             let child_ids_clone = child_ids.clone();
             let child_types = child_iter.map(|f| &f.mem.ty);
@@ -82,7 +82,7 @@ fn impl_derive_macro(ast: &syn::DeriveInput) -> TokenStream {
             let parent_iter = state_strct
                 .state_members
                 .iter()
-                .filter(|m| m.dep_kind == DepKind::ParentDepState);
+                .filter(|m| m.dep_kind == DepKind::Parent);
             let parent_ids = parent_iter.clone().map(|m| m.member_id.0);
             let parent_ids_clone = parent_ids.clone();
             let parent_types = parent_iter.map(|f| &f.mem.ty);
@@ -191,24 +191,22 @@ struct StateStruct<'a> {
 impl<'a> StateStruct<'a> {
     fn parse(fields: &[&'a Field], strct: &'a Struct) -> Result<Self> {
         let mut parse_err = Ok(());
-        let state_members: Vec<_> = strct
+        let state_members = strct
             .members
             .iter()
             .zip(fields.iter())
-            .filter_map(|(m, f)| match StateMember::parse(f, m, &strct) {
+            .filter_map(|(m, f)| match StateMember::parse(f, m, strct) {
                 Ok(m) => m,
                 Err(err) => {
                     parse_err = Err(err);
                     None
                 }
-            })
-            .collect();
-        parse_err?;
+            });
 
         #[derive(Debug, Clone)]
         struct DepNode<'a> {
             state_mem: StateMember<'a>,
-            depandants: Vec<Box<DepNode<'a>>>,
+            depandants: Vec<DepNode<'a>>,
         }
         impl<'a> DepNode<'a> {
             fn new(state_mem: StateMember<'a>) -> Self {
@@ -266,15 +264,14 @@ impl<'a> StateStruct<'a> {
             fn kind(&self) -> Result<&DepKind> {
                 fn reduce_kind<'a>(dk1: &'a DepKind, dk2: &'a DepKind) -> Result<&'a DepKind> {
                     match (dk1, dk2) {
-                        (DepKind::ChildDepState, DepKind::ParentDepState)
-                        | (DepKind::ParentDepState, DepKind::ChildDepState) => Err(Error::new(
-                            Span::call_site(),
-                            "There is a ChildDepState that depends on a ParentDepState",
-                        )),
-                        // node dep state takes the lowest priority
-                        (DepKind::NodeDepState, important) | (important, DepKind::NodeDepState) => {
-                            Ok(important)
+                        (DepKind::Child, DepKind::Parent) | (DepKind::Parent, DepKind::Child) => {
+                            Err(Error::new(
+                                Span::call_site(),
+                                "There is a ChildDepState that depends on a ParentDepState",
+                            ))
                         }
+                        // node dep state takes the lowest priority
+                        (DepKind::Node, important) | (important, DepKind::Node) => Ok(important),
                         // they are the same
                         (fst, _) => Ok(fst),
                     }
@@ -282,9 +279,7 @@ impl<'a> StateStruct<'a> {
                 reduce_kind(
                     self.depandants
                         .iter()
-                        .try_fold(&DepKind::NodeDepState, |dk1, dk2| {
-                            reduce_kind(dk1, dk2.kind()?)
-                        })?,
+                        .try_fold(&DepKind::Node, |dk1, dk2| reduce_kind(dk1, dk2.kind()?))?,
                     &self.state_mem.dep_kind,
                 )
             }
@@ -293,7 +288,7 @@ impl<'a> StateStruct<'a> {
                 let dep = other.state_mem.dep_mem.unwrap();
                 if self.contains_member(dep) {
                     if self.state_mem.mem == dep {
-                        self.depandants.push(Box::new(other));
+                        self.depandants.push(other);
                         true
                     } else {
                         self.depandants
@@ -310,7 +305,7 @@ impl<'a> StateStruct<'a> {
 
         // members need to be sorted so that members are updated after the members they depend on
         let mut roots: Vec<DepNode> = vec![];
-        for m in state_members.into_iter() {
+        for m in state_members {
             if let Some(dep) = m.dep_mem {
                 let root_depends_on = roots
                     .iter()
@@ -342,6 +337,7 @@ impl<'a> StateStruct<'a> {
             }
             roots.push(new);
         }
+        parse_err?;
         let mut current_id = 0;
         for r in &mut roots {
             r.set_ids(&mut current_id);
@@ -351,8 +347,7 @@ impl<'a> StateStruct<'a> {
         } else {
             let state_members: Vec<_> = roots
                 .into_iter()
-                .map(|r| r.flatten().into_iter())
-                .flatten()
+                .flat_map(|r| r.flatten().into_iter())
                 .collect();
 
             Ok(Self { state_members })
@@ -417,13 +412,12 @@ impl<'a> StateMember<'a> {
             let dep_kind = a
                 .path
                 .get_ident()
-                .map(|i| match i.to_string().as_str() {
-                    "node_dep_state" => Some(DepKind::NodeDepState),
-                    "child_dep_state" => Some(DepKind::ChildDepState),
-                    "parent_dep_state" => Some(DepKind::ParentDepState),
+                .and_then(|i| match i.to_string().as_str() {
+                    "node_dep_state" => Some(DepKind::Node),
+                    "child_dep_state" => Some(DepKind::Child),
+                    "parent_dep_state" => Some(DepKind::Parent),
                     _ => None,
-                })
-                .flatten()?;
+                })?;
             match a.parse_args::<Dependancy>() {
                 Ok(dependancy) => {
                     let dep_mem = if let Some(name) = &dependancy.dep {
@@ -474,27 +468,27 @@ impl<'a> StateMember<'a> {
             let child_dep = self
                 .dependants
                 .iter()
-                .filter(|(_, kind)| kind == &DepKind::ChildDepState)
+                .filter(|(_, kind)| kind == &DepKind::Child)
                 .map(|(id, _)| id.0);
             let parent_dep = self
                 .dependants
                 .iter()
-                .filter(|(_, kind)| kind == &DepKind::ParentDepState)
+                .filter(|(_, kind)| kind == &DepKind::Parent)
                 .map(|(id, _)| id.0);
             let node_dep = self
                 .dependants
                 .iter()
-                .filter(|(_, kind)| kind == &DepKind::NodeDepState)
+                .filter(|(_, kind)| kind == &DepKind::Node)
                 .map(|(id, _)| id.0);
             match self.dep_kind {
-                DepKind::NodeDepState => {
+                DepKind::Node => {
                     quote! {
                         dioxus_native_core::state::NodeStatesChanged{
                             node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
                         }
                     }
                 }
-                DepKind::ChildDepState => {
+                DepKind::Child => {
                     quote! {
                         dioxus_native_core::state::ChildStatesChanged{
                             node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
@@ -502,7 +496,7 @@ impl<'a> StateMember<'a> {
                         }
                     }
                 }
-                DepKind::ParentDepState => {
+                DepKind::Parent => {
                     quote! {
                         dioxus_native_core::state::ParentStatesChanged{
                             node_dep: &[#(dioxus_native_core::state::MemberId(#node_dep), )*],
@@ -519,7 +513,7 @@ impl<'a> StateMember<'a> {
         let id = self.member_id.0;
         if let Some(dep_ident) = &self.dep_mem.map(|m| &m.ident) {
             match self.dep_kind {
-                DepKind::NodeDepState => {
+                DepKind::Node => {
                     quote!({
                         // println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
                         if self.#ident.reduce(#node_view, &self.#dep_ident, #get_ctx){
@@ -529,7 +523,7 @@ impl<'a> StateMember<'a> {
                         }
                     })
                 }
-                DepKind::ChildDepState => {
+                DepKind::Child => {
                     quote!({
                         // println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
                         if self.#ident.reduce(#node_view, children.iter().map(|s| &s.#dep_ident), #get_ctx){
@@ -539,7 +533,7 @@ impl<'a> StateMember<'a> {
                         }
                     })
                 }
-                DepKind::ParentDepState => {
+                DepKind::Parent => {
                     quote!({
                         // println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
                         if self.#ident.reduce(#node_view, parent.as_ref().map(|p| &p.#dep_ident), #get_ctx){
@@ -552,7 +546,7 @@ impl<'a> StateMember<'a> {
             }
         } else {
             match self.dep_kind {
-                DepKind::NodeDepState => {
+                DepKind::Node => {
                     quote!({
                         // println!("node: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
                         if self.#ident.reduce(#node_view, &(), #get_ctx){
@@ -562,7 +556,7 @@ impl<'a> StateMember<'a> {
                         }
                     })
                 }
-                DepKind::ChildDepState => {
+                DepKind::Child => {
                     quote!({
                         // println!("child: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
                         if self.#ident.reduce(#node_view, std::iter::empty(), #get_ctx){
@@ -572,7 +566,7 @@ impl<'a> StateMember<'a> {
                         }
                     })
                 }
-                DepKind::ParentDepState => {
+                DepKind::Parent => {
                     quote!({
                         println!("parent: {:?} {:?} {:?}", self.#ident, #id, #node_view.id());
                         if self.#ident.reduce(#node_view, Some(&()), #get_ctx){

packages/native-core/src/node_ref.rs

@@ -30,7 +30,7 @@ impl<'a> NodeView<'a> {
     pub fn namespace(&self) -> Option<&'a str> {
         self.mask
             .namespace
-            .then(|| self.el().map(|el| el.namespace).flatten())
+            .then(|| self.el().and_then(|el| el.namespace))
             .flatten()
     }
 
@@ -39,7 +39,7 @@ impl<'a> NodeView<'a> {
             .map(|el| el.attributes)
             .unwrap_or_default()
             .iter()
-            .filter(|a| self.mask.attritutes.contains_attribute(&a.name))
+            .filter(|a| self.mask.attritutes.contains_attribute(a.name))
     }
 
     pub fn text(&self) -> Option<&str> {
@@ -124,11 +124,11 @@ impl AttributeMask {
 
     fn overlaps(&self, other: &Self) -> bool {
         fn overlaps_iter(
-            mut self_iter: impl Iterator<Item = &'static str>,
+            self_iter: impl Iterator<Item = &'static str>,
             mut other_iter: impl Iterator<Item = &'static str>,
         ) -> bool {
             if let Some(mut other_attr) = other_iter.next() {
-                while let Some(self_attr) = self_iter.next() {
+                for self_attr in self_iter {
                     while other_attr < self_attr {
                         if let Some(attr) = other_iter.next() {
                             other_attr = attr;

packages/native-core/src/real_dom.rs

@@ -390,7 +390,7 @@ impl<S: State> RealDom<S> {
         }
 
         // push down state. To avoid calling reduce more times than nessisary start from the top and go down.
-        let mut to_push = nodes_updated.clone();
+        let mut to_push = nodes_updated;
         while let Some(node_ref) = to_push.pop_front() {
             let NodeRef {
                 id,
@@ -528,10 +528,10 @@ impl<S: State> RealDom<S> {
     }
 
     // this is safe because no node will have itself as a child
-    pub fn get_node_children_mut<'a>(
-        &'a mut self,
+    pub fn get_node_children_mut(
+        &mut self,
         id: usize,
-    ) -> Option<(&'a mut Node<S>, Vec<&'a mut Node<S>>)> {
+    ) -> Option<(&mut Node<S>, Vec<&mut Node<S>>)> {
         let ptr = self.nodes.as_mut_ptr();
         unsafe {
             if id >= self.nodes.len() {
@@ -546,7 +546,7 @@ impl<S: State> RealDom<S> {
                             .collect(),
                         _ => Vec::new(),
                     };
-                    return Some((node, children));
+                    Some((node, children))
                 } else {
                     None
                 }
@@ -555,24 +555,22 @@ impl<S: State> RealDom<S> {
     }
 
     // this is safe because no node will have itself as a parent
-    pub fn get_node_parent_mut<'a>(
-        &'a mut self,
+    pub fn get_node_parent_mut(
+        &mut self,
         id: usize,
-    ) -> Option<(&'a mut Node<S>, Option<&'a mut Node<S>>)> {
+    ) -> Option<(&mut Node<S>, Option<&mut Node<S>>)> {
         let ptr = self.nodes.as_mut_ptr();
         unsafe {
             let node = &mut *ptr.add(id);
             if id >= self.nodes.len() {
                 None
+            } else if let Some(node) = node.as_mut() {
+                let parent = node
+                    .parent
+                    .map(|id| (&mut *ptr.add(id.0)).as_mut().unwrap());
+                Some((node, parent))
             } else {
-                if let Some(node) = node.as_mut() {
-                    let parent = node
-                        .parent
-                        .map(|id| (&mut *ptr.add(id.0)).as_mut().unwrap());
-                    return Some((node, parent));
-                } else {
-                    None
-                }
+                None
             }
         }
     }

packages/native-core/src/state.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::{cmp::Ordering, fmt::Debug};
 
 use anymap::AnyMap;
 use dioxus_core::VNode;
@@ -14,20 +14,20 @@ pub(crate) fn union_ordered_iter<T: Ord + Debug>(
     let mut o_peekable = o_iter.peekable();
     let mut v = Vec::with_capacity(new_len_guess);
     while let Some(s_i) = s_peekable.peek() {
-        loop {
-            if let Some(o_i) = o_peekable.peek() {
-                if o_i > s_i {
+        while let Some(o_i) = o_peekable.peek() {
+            match o_i.cmp(s_i) {
+                Ordering::Greater => {
                     break;
-                } else if o_i < s_i {
+                }
+                Ordering::Less => {
                     v.push(o_peekable.next().unwrap());
                 }
-            } else {
-                break;
+                Ordering::Equal => (),
             }
         }
         v.push(s_peekable.next().unwrap());
     }
-    while let Some(o_i) = o_peekable.next() {
+    for o_i in o_peekable {
         v.push(o_i);
     }
     for w in v.windows(2) {

packages/tui/src/hooks.rs

@@ -161,7 +161,7 @@ impl InnerInputState {
 
     fn update(
         &mut self,
-        evts: &mut Vec<EventCore>,
+        evts: &mut [EventCore],
         resolved_events: &mut Vec<UserEvent>,
         layout: &Stretch,
         dom: &mut Dom,

packages/tui/src/layout.rs

@@ -115,7 +115,7 @@ impl ChildDepState for StretchLayout {
 }
 
 // these are the attributes in layout_attiributes in native-core
-const SORTED_LAYOUT_ATTRS: &'static [&'static str] = &sorted_str_slice!([
+const SORTED_LAYOUT_ATTRS: &[&str] = &sorted_str_slice!([
     "align-content",
     "align-items",
     "align-self",

packages/tui/src/lib.rs

@@ -166,7 +166,7 @@ fn render_vdom(
                             // size is guaranteed to not change when rendering
                             resize(frame.size(), &mut stretch.borrow_mut(), &rdom);
                             let root = &rdom[0];
-                            render::render_vnode(frame, &stretch.borrow(), &rdom, &root, cfg);
+                            render::render_vnode(frame, &stretch.borrow(), &rdom, root, cfg);
                         })?;
                     } else {
                         resize(
@@ -226,7 +226,7 @@ fn render_vdom(
                     // update the style and layout
                     let mut any_map = AnyMap::new();
                     any_map.insert(stretch.clone());
-                    let _to_rerender = rdom.update_state(&vdom, to_update, any_map).unwrap();
+                    let _to_rerender = rdom.update_state(vdom, to_update, any_map).unwrap();
                 }
             }
 

packages/tui/src/style_attributes.rs

@@ -590,7 +590,7 @@ fn apply_transition(_name: &str, _value: &str, _style: &mut StyleModifier) {
     todo!()
 }
 
-const SORTED_STYLE_ATTRS: &'static [&'static str] = &sorted_str_slice!([
+const SORTED_STYLE_ATTRS: &[&str] = &sorted_str_slice!([
     "animation",
     "animation-delay",
     "animation-direction",