swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: enable a pedantic clippy on the diffing algorithm

Browse Source
This commit is contained in:
Jonathan Kelley committed 2022-01-31 12:49:21 -05:00
1 parent 06418f73db
commit c4e6496d9d
2 files changed
+56 -81
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/core/src/diff.rs
+56 -74
View File
@@ -1,4 +1,10 @@
use crate::innerlude::*; #![warn(clippy::pedantic)]
#![allow(clippy::cast_possible_truncation)]
use crate::innerlude::{
AnyProps, ElementId, Mutations, ScopeArena, ScopeId, VComponent, VElement, VFragment, VNode,
VPlaceholder, VText,
};
use fxhash::{FxHashMap, FxHashSet}; use fxhash::{FxHashMap, FxHashSet};
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
@@ -33,7 +39,7 @@ impl<'b> DiffState<'b> {
} }
pub fn diff_node(&mut self, old_node: &'b VNode<'b>, new_node: &'b VNode<'b>) { pub fn diff_node(&mut self, old_node: &'b VNode<'b>, new_node: &'b VNode<'b>) {
use VNode::*; use VNode::{Component, Element, Fragment, Placeholder, Text};
match (old_node, new_node) { match (old_node, new_node) {
// Check the most common cases first // Check the most common cases first
// these are *actual* elements, not wrappers around lists // these are *actual* elements, not wrappers around lists
@@ -61,7 +67,7 @@ impl<'b> DiffState<'b> {
if let Some(root) = old.id.get() { if let Some(root) = old.id.get() {
self.scopes.update_node(new_node, root); self.scopes.update_node(new_node, root);
new.id.set(Some(root)) new.id.set(Some(root));
} }
} }
@@ -70,7 +76,7 @@ impl<'b> DiffState<'b> {
log::trace!("skipping node diff - element are the sames"); log::trace!("skipping node diff - element are the sames");
return; return;
} }
self.diff_element_nodes(old, new, old_node, new_node) self.diff_element_nodes(old, new, old_node, new_node);
} }
// These two sets are pointers to nodes but are not actually nodes themselves // These two sets are pointers to nodes but are not actually nodes themselves
@@ -79,7 +85,7 @@ impl<'b> DiffState<'b> {
log::trace!("skipping node diff - placeholder are the sames"); log::trace!("skipping node diff - placeholder are the sames");
return; return;
} }
self.diff_component_nodes(old_node, new_node, *old, *new) self.diff_component_nodes(old_node, new_node, *old, *new);
} }
(Fragment(old), Fragment(new)) => { (Fragment(old), Fragment(new)) => {
@@ -87,7 +93,7 @@ impl<'b> DiffState<'b> {
log::trace!("skipping node diff - fragment are the sames"); log::trace!("skipping node diff - fragment are the sames");
return; return;
} }
self.diff_fragment_nodes(old, new) self.diff_fragment_nodes(old, new);
} }
// Anything else is just a basic replace and create // Anything else is just a basic replace and create
@@ -136,17 +142,15 @@ impl<'b> DiffState<'b> {
.. ..
} = element; } = element;
// set the parent ID for event bubbling
// self.stack.instructions.push(DiffInstruction::PopElement);
let parent = self.element_stack.last().unwrap(); let parent = self.element_stack.last().unwrap();
parent_id.set(Some(*parent)); parent_id.set(Some(*parent));
// set the id of the element // set the id of the element
let real_id = self.scopes.reserve_node(node); let real_id = self.scopes.reserve_node(node);
self.element_stack.push(real_id);
dom_id.set(Some(real_id)); dom_id.set(Some(real_id));
self.element_stack.push(real_id);
self.mutations.create_element(tag_name, *namespace, real_id); self.mutations.create_element(tag_name, *namespace, real_id);
if let Some(cur_scope_id) = self.current_scope() { if let Some(cur_scope_id) = self.current_scope() {
@@ -155,7 +159,7 @@ impl<'b> DiffState<'b> {
self.mutations.new_event_listener(listener, cur_scope_id); self.mutations.new_event_listener(listener, cur_scope_id);
} }
} else { } else {
log::warn!("create element called with no scope on the stack - this is an error for a live dom"); log::trace!("create element called with no scope on the stack - this is an error for a live dom");
} }
for attr in *attributes { for attr in *attributes {
@@ -198,7 +202,7 @@ impl<'b> DiffState<'b> {
new_idx new_idx
}; };
log::info!( log::trace!(
"created component \"{}\", id: {:?} parent {:?} orig: {:?}", "created component \"{}\", id: {:?} parent {:?} orig: {:?}",
vcomponent.fn_name, vcomponent.fn_name,
new_idx, new_idx,
@@ -209,14 +213,11 @@ impl<'b> DiffState<'b> {
// Actually initialize the caller's slot with the right address // Actually initialize the caller's slot with the right address
vcomponent.scope.set(Some(new_idx)); vcomponent.scope.set(Some(new_idx));
match vcomponent.can_memoize { // if vcomponent.can_memoize {
true => { // // todo: implement promotion logic. save us from boxing props that we don't need
// todo: implement promotion logic. save us from boxing props that we don't need // } else {
} // // track this component internally so we know the right drop order
false => { // }
// track this component internally so we know the right drop order
}
}
self.enter_scope(new_idx); self.enter_scope(new_idx);
@@ -278,7 +279,7 @@ impl<'b> DiffState<'b> {
self.mutations.remove_attribute(attribute, root.as_u64()); self.mutations.remove_attribute(attribute, root.as_u64());
} }
for attribute in new.attributes { for attribute in new.attributes {
self.mutations.set_attribute(attribute, root.as_u64()) self.mutations.set_attribute(attribute, root.as_u64());
} }
} }
@@ -318,9 +319,7 @@ impl<'b> DiffState<'b> {
let created = self.create_children(new.children); let created = self.create_children(new.children);
self.mutations.append_children(created as u32); self.mutations.append_children(created as u32);
} }
(_, _) => { (_, _) => self.diff_children(old.children, new.children),
self.diff_children(old.children, new.children);
}
}; };
} }
@@ -332,14 +331,8 @@ impl<'b> DiffState<'b> {
new: &'b VComponent<'b>, new: &'b VComponent<'b>,
) { ) {
let scope_addr = old.scope.get().unwrap(); let scope_addr = old.scope.get().unwrap();
log::trace!(
"diff_component_nodes. old: {:#?} new: {:#?}",
old_node,
new_node
);
if std::ptr::eq(old, new) { if std::ptr::eq(old, new) {
log::trace!("skipping component diff - component is the sames");
return; return;
} }
@@ -397,7 +390,6 @@ impl<'b> DiffState<'b> {
self.leave_scope(); self.leave_scope();
} else { } else {
log::debug!("scope stack is {:#?}", self.scope_stack);
self.replace_node(old_node, new_node); self.replace_node(old_node, new_node);
} }
} }
@@ -405,14 +397,12 @@ impl<'b> DiffState<'b> {
fn diff_fragment_nodes(&mut self, old: &'b VFragment<'b>, new: &'b VFragment<'b>) { fn diff_fragment_nodes(&mut self, old: &'b VFragment<'b>, new: &'b VFragment<'b>) {
// This is the case where options or direct vnodes might be used. // This is the case where options or direct vnodes might be used.
// In this case, it's faster to just skip ahead to their diff // In this case, it's faster to just skip ahead to their diff
// if old.children.len() == 1 && new.children.len() == 1 { if old.children.len() == 1 && new.children.len() == 1 {
// if std::ptr::eq(old, new) { if !std::ptr::eq(old, new) {
// log::debug!("skipping fragment diff - fragment is the same"); self.diff_node(&old.children[0], &new.children[0]);
// return; }
// } return;
// self.diff_node(&old.children[0], &new.children[0]); }
// return;
// }
debug_assert!(!old.children.is_empty()); debug_assert!(!old.children.is_empty());
debug_assert!(!new.children.is_empty()); debug_assert!(!new.children.is_empty());
@@ -441,7 +431,6 @@ impl<'b> DiffState<'b> {
// to an element, and appending makes sense. // to an element, and appending makes sense.
fn diff_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) { fn diff_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
if std::ptr::eq(old, new) { if std::ptr::eq(old, new) {
log::debug!("skipping fragment diff - fragment is the same {:?}", old);
return; return;
} }
@@ -481,24 +470,19 @@ impl<'b> DiffState<'b> {
// //
// the change list stack is in the same state when this function returns. // the change list stack is in the same state when this function returns.
fn diff_non_keyed_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) { fn diff_non_keyed_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
use std::cmp::Ordering;
// Handled these cases in `diff_children` before calling this function. // Handled these cases in `diff_children` before calling this function.
debug_assert!(!new.is_empty()); debug_assert!(!new.is_empty());
debug_assert!(!old.is_empty()); debug_assert!(!old.is_empty());
use std::cmp::Ordering;
match old.len().cmp(&new.len()) { match old.len().cmp(&new.len()) {
Ordering::Greater => self.remove_nodes(&old[new.len()..], true), Ordering::Greater => self.remove_nodes(&old[new.len()..], true),
Ordering::Less => self.create_and_insert_after(&new[old.len()..], old.last().unwrap()), Ordering::Less => self.create_and_insert_after(&new[old.len()..], old.last().unwrap()),
Ordering::Equal => {} Ordering::Equal => {}
} }
// panic!(
// "diff_children: new_is_keyed: {:#?}, old_is_keyed: {:#?}. stack: {:#?}, oldptr: {:#?}, newptr: {:#?}",
// old, new, self.scope_stack, old as *const _, new as *const _
// );
for (new, old) in new.iter().zip(old.iter()) { for (new, old) in new.iter().zip(old.iter()) {
// log::debug!("diffing nonkeyed {:#?} {:#?}", old, new);
self.diff_node(old, new); self.diff_node(old, new);
} }
} }
@@ -650,6 +634,7 @@ impl<'b> DiffState<'b> {
// This function will load the appropriate nodes onto the stack and do diffing in place. // This function will load the appropriate nodes onto the stack and do diffing in place.
// //
// Upon exit from this function, it will be restored to that same self. // Upon exit from this function, it will be restored to that same self.
#[allow(clippy::too_many_lines)]
fn diff_keyed_middle(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) { fn diff_keyed_middle(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
/* /*
1. Map the old keys into a numerical ordering based on indices. 1. Map the old keys into a numerical ordering based on indices.
@@ -675,8 +660,8 @@ impl<'b> DiffState<'b> {
// 0. Debug sanity checks // 0. Debug sanity checks
// Should have already diffed the shared-key prefixes and suffixes. // Should have already diffed the shared-key prefixes and suffixes.
debug_assert_ne!(new.first().map(|n| n.key()), old.first().map(|o| o.key())); debug_assert_ne!(new.first().map(VNode::key), old.first().map(VNode::key));
debug_assert_ne!(new.last().map(|n| n.key()), old.last().map(|o| o.key())); debug_assert_ne!(new.last().map(VNode::key), old.last().map(VNode::key));
// 1. Map the old keys into a numerical ordering based on indices. // 1. Map the old keys into a numerical ordering based on indices.
// 2. Create a map of old key to its index // 2. Create a map of old key to its index
@@ -741,7 +726,7 @@ impl<'b> DiffState<'b> {
lis_sequence.pop(); lis_sequence.pop();
} }
for idx in lis_sequence.iter() { for idx in &lis_sequence {
self.diff_node(&old[new_index_to_old_index[*idx]], &new[*idx]); self.diff_node(&old[new_index_to_old_index[*idx]], &new[*idx]);
} }
@@ -775,7 +760,6 @@ impl<'b> DiffState<'b> {
if last - next > 1 { if last - next > 1 {
for (idx, new_node) in new[(next + 1)..last].iter().enumerate() { for (idx, new_node) in new[(next + 1)..last].iter().enumerate() {
let new_idx = idx + next + 1; let new_idx = idx + next + 1;
let old_index = new_index_to_old_index[new_idx]; let old_index = new_index_to_old_index[new_idx];
if old_index == u32::MAX as usize { if old_index == u32::MAX as usize {
nodes_created += self.create_node(new_node); nodes_created += self.create_node(new_node);
@@ -816,7 +800,6 @@ impl<'b> DiffState<'b> {
} }
fn replace_node(&mut self, old: &'b VNode<'b>, new: &'b VNode<'b>) { fn replace_node(&mut self, old: &'b VNode<'b>, new: &'b VNode<'b>) {
log::debug!("Replacing node\n old: {:?}\n new: {:?}", old, new);
let nodes_created = self.create_node(new); let nodes_created = self.create_node(new);
self.replace_inner(old, nodes_created); self.replace_inner(old, nodes_created);
} }
@@ -848,7 +831,7 @@ impl<'b> DiffState<'b> {
} }
VNode::Component(c) => { VNode::Component(c) => {
log::info!("Replacing component {:?}", old); log::trace!("Replacing component {:?}", old);
let scope_id = c.scope.get().unwrap(); let scope_id = c.scope.get().unwrap();
let node = self.scopes.fin_head(scope_id); let node = self.scopes.fin_head(scope_id);
@@ -856,11 +839,11 @@ impl<'b> DiffState<'b> {
self.replace_inner(node, nodes_created); self.replace_inner(node, nodes_created);
log::info!("Replacing component x2 {:?}", old); log::trace!("Replacing component x2 {:?}", old);
// we can only remove components if they are actively being diffed // we can only remove components if they are actively being diffed
if self.scope_stack.contains(&c.originator) { if self.scope_stack.contains(&c.originator) {
log::debug!("Removing component {:?}", old); log::trace!("Removing component {:?}", old);
self.scopes.try_remove(scope_id).unwrap(); self.scopes.try_remove(scope_id).unwrap();
} }
@@ -913,7 +896,7 @@ impl<'b> DiffState<'b> {
let root = self.scopes.root_node(scope_id); let root = self.scopes.root_node(scope_id);
self.remove_nodes([root], gen_muts); self.remove_nodes([root], gen_muts);
log::info!( log::trace!(
"trying to remove scope {:?}, stack is {:#?}, originator is {:?}", "trying to remove scope {:?}, stack is {:#?}, originator is {:?}",
scope_id, scope_id,
self.scope_stack, self.scope_stack,
@@ -922,7 +905,7 @@ impl<'b> DiffState<'b> {
// we can only remove this node if the originator is actively // we can only remove this node if the originator is actively
if self.scope_stack.contains(&c.originator) { if self.scope_stack.contains(&c.originator) {
log::debug!("I am allowed to remove component because scope stack contains originator. Scope stack: {:#?} {:#?} {:#?}", self.scope_stack, c.originator, c.scope); log::trace!("I am allowed to remove component because scope stack contains originator. Scope stack: {:#?} {:#?} {:#?}", self.scope_stack, c.originator, c.scope);
self.scopes.try_remove(scope_id).unwrap(); self.scopes.try_remove(scope_id).unwrap();
} }
self.leave_scope(); self.leave_scope();
@@ -970,15 +953,12 @@ impl<'b> DiffState<'b> {
fn find_last_element(&self, vnode: &'b VNode<'b>) -> Option<ElementId> { fn find_last_element(&self, vnode: &'b VNode<'b>) -> Option<ElementId> {
let mut search_node = Some(vnode); let mut search_node = Some(vnode);
loop { loop {
match &search_node.take().unwrap() { match &search_node.take().unwrap() {
VNode::Text(t) => break t.id.get(), VNode::Text(t) => break t.id.get(),
VNode::Element(t) => break t.id.get(), VNode::Element(t) => break t.id.get(),
VNode::Placeholder(t) => break t.id.get(), VNode::Placeholder(t) => break t.id.get(),
VNode::Fragment(frag) => { VNode::Fragment(frag) => search_node = frag.children.last(),
search_node = frag.children.last();
}
VNode::Component(el) => { VNode::Component(el) => {
let scope_id = el.scope.get().unwrap(); let scope_id = el.scope.get().unwrap();
search_node = Some(self.scopes.root_node(scope_id)); search_node = Some(self.scopes.root_node(scope_id));
@@ -989,20 +969,16 @@ impl<'b> DiffState<'b> {
fn find_first_element(&self, vnode: &'b VNode<'b>) -> Option<ElementId> { fn find_first_element(&self, vnode: &'b VNode<'b>) -> Option<ElementId> {
let mut search_node = Some(vnode); let mut search_node = Some(vnode);
loop { loop {
match &search_node.take().unwrap() { match &search_node.take().expect("search node to have an ID") {
// the ones that have a direct id
VNode::Fragment(frag) => {
search_node = Some(&frag.children[0]);
}
VNode::Component(el) => {
let scope_id = el.scope.get().unwrap();
search_node = Some(self.scopes.root_node(scope_id));
}
VNode::Text(t) => break t.id.get(), VNode::Text(t) => break t.id.get(),
VNode::Element(t) => break t.id.get(), VNode::Element(t) => break t.id.get(),
VNode::Placeholder(t) => break t.id.get(), VNode::Placeholder(t) => break t.id.get(),
VNode::Fragment(frag) => search_node = Some(&frag.children[0]),
VNode::Component(el) => {
let scope = el.scope.get().expect("element to have a scope assigned");
search_node = Some(self.scopes.root_node(scope));
}
} }
} }
} }
@@ -1015,20 +991,26 @@ impl<'b> DiffState<'b> {
1 1
} }
VNode::Fragment(_) | VNode::Component(_) => { VNode::Fragment(frag) => {
//
let mut added = 0; let mut added = 0;
for child in node.children() { for child in frag.children {
added += self.push_all_nodes(child); added += self.push_all_nodes(child);
} }
added added
} }
VNode::Component(c) => {
let scope_id = c.scope.get().unwrap();
let root = self.scopes.root_node(scope_id);
self.push_all_nodes(root)
}
VNode::Element(el) => { VNode::Element(el) => {
let mut num_on_stack = 0; let mut num_on_stack = 0;
for child in el.children.iter() { for child in el.children.iter() {
num_on_stack += self.push_all_nodes(child); num_on_stack += self.push_all_nodes(child);
} }
self.mutations.push_root(el.id.get().unwrap()); self.mutations.push_root(el.id.get().unwrap());
num_on_stack + 1 num_on_stack + 1
packages/core/src/nodes.rs
-7
View File
@@ -147,13 +147,6 @@ impl<'src> VNode<'src> {
} }
} }
pub(crate) fn children(&self) -> &[VNode<'src>] {
match &self {
VNode::Fragment(f) => f.children,
_ => &[],
}
}
// Create an "owned" version of the vnode. // Create an "owned" version of the vnode.
pub fn decouple(&self) -> VNode<'src> { pub fn decouple(&self) -> VNode<'src> {
match *self { match *self {