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

wip: compiles again

Browse Source
This commit is contained in:
Jonathan Kelley committed 2021-08-23 10:43:49 -04:00
1 parent db6d0184aa
commit 16bfc6d248
10 files changed
+534 -508
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/core/src/childiter.rs
+130
View File
@@ -0,0 +1,130 @@
use crate::innerlude::*;
/// This iterator iterates through a list of virtual children and only returns real children (Elements, Text, Anchors).
///
/// This iterator is useful when it's important to load the next real root onto the top of the stack for operations like
/// "InsertBefore".
pub struct RealChildIterator<'a> {
scopes: &'a SharedResources,
// Heuristcally we should never bleed into 4 completely nested fragments/components
// Smallvec lets us stack allocate our little stack machine so the vast majority of cases are sane
// TODO: use const generics instead of the 4 estimation
stack: smallvec::SmallVec<[(u16, &'a VNode<'a>); 4]>,
}
impl<'a> RealChildIterator<'a> {
pub fn new(starter: &'a VNode<'a>, scopes: &'a SharedResources) -> Self {
Self {
scopes,
stack: smallvec::smallvec![(0, starter)],
}
}
pub fn new_from_slice(nodes: &'a [VNode<'a>], scopes: &'a SharedResources) -> Self {
let mut stack = smallvec::smallvec![];
for node in nodes {
stack.push((0, node));
}
Self { scopes, stack }
}
// keep the memory around
pub fn reset_with(&mut self, node: &'a VNode<'a>) {
self.stack.clear();
self.stack.push((0, node));
}
}
impl<'a> Iterator for RealChildIterator<'a> {
type Item = &'a VNode<'a>;
fn next(&mut self) -> Option<&'a VNode<'a>> {
let mut should_pop = false;
let mut returned_node: Option<&'a VNode<'a>> = None;
let mut should_push = None;
while returned_node.is_none() {
if let Some((count, node)) = self.stack.last_mut() {
match &node {
// We can only exit our looping when we get "real" nodes
// This includes fragments and components when they're empty (have a single root)
VNode::Element(_) | VNode::Text(_) => {
// We've recursed INTO an element/text
// We need to recurse *out* of it and move forward to the next
should_pop = true;
returned_node = Some(&*node);
}
// If we get a fragment we push the next child
VNode::Fragment(frag) => {
let subcount = *count as usize;
if frag.children.len() == 0 {
should_pop = true;
returned_node = Some(&*node);
}
if subcount >= frag.children.len() {
should_pop = true;
} else {
should_push = Some(&frag.children[subcount]);
}
}
// // If we get a fragment we push the next child
// VNodeKind::Fragment(frag) => {
// let subcount = *count as usize;
// if frag.children.len() == 0 {
// should_pop = true;
// returned_node = Some(&*node);
// }
// if subcount >= frag.children.len() {
// should_pop = true;
// } else {
// should_push = Some(&frag.children[subcount]);
// }
// }
// Immediately abort suspended nodes - can't do anything with them yet
VNode::Suspended(node) => {
// VNodeKind::Suspended => should_pop = true,
todo!()
}
VNode::Anchor(a) => {
todo!()
}
// For components, we load their root and push them onto the stack
VNode::Component(sc) => {
let scope =
unsafe { self.scopes.get_scope(sc.ass_scope.get().unwrap()) }.unwrap();
// let scope = self.scopes.get(sc.ass_scope.get().unwrap()).unwrap();
// Simply swap the current node on the stack with the root of the component
*node = scope.frames.fin_head();
}
}
} else {
// If there's no more items on the stack, we're done!
return None;
}
if should_pop {
self.stack.pop();
if let Some((id, _)) = self.stack.last_mut() {
*id += 1;
}
should_pop = false;
}
if let Some(push) = should_push {
self.stack.push((0, push));
should_push = None;
}
}
returned_node
}
}
packages/core/src/diff.rs
+162 -452
View File
@@ -110,63 +110,13 @@ pub struct DiffMachine<'bump> {
pub mutations: Mutations<'bump>,
pub nodes_created_stack: SmallVec<[usize; 10]>,
pub instructions: Vec<DiffInstruction<'bump>>,
pub scope_stack: SmallVec<[ScopeId; 5]>,
pub stack: DiffStack<'bump>,
pub diffed: FxHashSet<ScopeId>,
pub seen_scopes: FxHashSet<ScopeId>,
}
/// The stack instructions we use to diff and create new nodes.
///
/// These instructions are essentially mini state machines that stay on top of the stack until they are finished.
#[derive(Debug)]
pub enum DiffInstruction<'a> {
DiffNode {
old: &'a VNode<'a>,
new: &'a VNode<'a>,
},
DiffChildren {
old: &'a [VNode<'a>],
new: &'a [VNode<'a>],
},
Create {
node: &'a VNode<'a>,
and: MountType<'a>,
},
Remove {
child: &'a VNode<'a>,
},
RemoveChildren {
children: &'a [VNode<'a>],
},
Mount {
and: MountType<'a>,
},
PopElement,
PopScope,
}
#[derive(Debug, Clone, Copy)]
pub enum MountType<'a> {
Absorb,
Append,
Replace { old: &'a VNode<'a> },
InsertAfter { other_node: Option<&'a VNode<'a>> },
InsertBefore { other_node: Option<&'a VNode<'a>> },
}
impl<'bump> DiffMachine<'bump> {
pub(crate) fn new(
edits: Mutations<'bump>,
@@ -174,10 +124,8 @@ impl<'bump> DiffMachine<'bump> {
shared: &'bump SharedResources,
) -> Self {
Self {
instructions: Vec::with_capacity(1000),
nodes_created_stack: smallvec![],
stack: DiffStack::new(cur_scope),
mutations: edits,
scope_stack: smallvec![cur_scope],
vdom: shared,
diffed: FxHashSet::default(),
seen_scopes: FxHashSet::default(),
@@ -192,7 +140,10 @@ impl<'bump> DiffMachine<'bump> {
//
pub async fn diff_scope(&mut self, id: ScopeId) -> Result<()> {
let component = self.get_scope_mut(&id).ok_or_else(|| Error::NotMounted)?;
let component = self
.vdom
.get_scope_mut(id)
.ok_or_else(|| Error::NotMounted)?;
let (old, new) = (component.frames.wip_head(), component.frames.fin_head());
self.diff_node(old, new);
Ok(())
@@ -206,7 +157,7 @@ impl<'bump> DiffMachine<'bump> {
pub async fn work(&mut self) -> Result<()> {
// defer to individual functions so the compiler produces better code
// large functions tend to be difficult for the compiler to work with
while let Some(instruction) = self.instructions.pop() {
while let Some(instruction) = self.stack.pop() {
log::debug!("Handling diff instruction: {:?}", instruction);
// todo: call this less frequently, there is a bit of overhead involved
@@ -214,7 +165,7 @@ impl<'bump> DiffMachine<'bump> {
match instruction {
DiffInstruction::PopScope => {
self.scope_stack.pop();
self.stack.pop_scope();
}
DiffInstruction::PopElement => {
self.mutations.pop();
@@ -229,22 +180,18 @@ impl<'bump> DiffMachine<'bump> {
}
DiffInstruction::Create { node, and } => {
self.nodes_created_stack.push(0);
self.instructions.push(DiffInstruction::Mount { and });
self.create_node(node);
}
DiffInstruction::Remove { child } => {
for child in RealChildIterator::new(child, self.vdom) {
self.mutations.push_root(child.direct_id());
self.mutations.remove();
self.mutations.remove(child.direct_id().as_u64());
}
}
DiffInstruction::RemoveChildren { children } => {
for child in RealChildIterator::new_from_slice(children, self.vdom) {
self.mutations.push_root(child.direct_id());
self.mutations.remove();
self.mutations.remove(child.direct_id().as_u64());
}
}
@@ -258,12 +205,12 @@ impl<'bump> DiffMachine<'bump> {
}
fn mount(&mut self, and: MountType) {
let nodes_created = self.nodes_created_stack.pop().unwrap();
let nodes_created = self.stack.nodes_created_stack.pop().unwrap();
match and {
// add the nodes from this virtual list to the parent
// used by fragments and components
MountType::Absorb => {
*self.nodes_created_stack.last_mut().unwrap() += nodes_created;
*self.stack.nodes_created_stack.last_mut().unwrap() += nodes_created;
}
MountType::Append => {
self.mutations.edits.push(AppendChildren {
@@ -303,21 +250,21 @@ impl<'bump> DiffMachine<'bump> {
let real_id = self.vdom.reserve_node();
self.mutations.create_text_node(vtext.text, real_id);
vtext.dom_id.set(Some(real_id));
*self.nodes_created_stack.last_mut().unwrap() += 1;
self.stack.add_child_count(1);
}
fn create_suspended_node(&mut self, suspended: &'bump VSuspended) {
let real_id = self.vdom.reserve_node();
self.mutations.create_placeholder(real_id);
suspended.node.set(Some(real_id));
*self.nodes_created_stack.last_mut().unwrap() += 1;
self.stack.add_child_count(1);
}
fn create_anchor_node(&mut self, anchor: &'bump VAnchor) {
let real_id = self.vdom.reserve_node();
self.mutations.create_placeholder(real_id);
anchor.dom_id.set(Some(real_id));
*self.nodes_created_stack.last_mut().unwrap() += 1;
self.stack.add_child_count(1);
}
fn create_element_node(&mut self, element: &'bump VElement<'bump>) {
@@ -334,11 +281,11 @@ impl<'bump> DiffMachine<'bump> {
let real_id = self.vdom.reserve_node();
self.mutations.create_element(tag_name, *namespace, real_id);
*self.nodes_created_stack.last_mut().unwrap() += 1;
self.stack.add_child_count(1);
dom_id.set(Some(real_id));
let cur_scope = self.current_scope().unwrap();
let cur_scope = self.stack.current_scope().unwrap();
listeners.iter().for_each(|listener| {
self.fix_listener(listener);
@@ -352,22 +299,22 @@ impl<'bump> DiffMachine<'bump> {
}
if children.len() > 0 {
self.create_children_instructions(children, MountType::Append);
self.stack.create_children(children, MountType::Append);
}
}
fn create_fragment_node(&mut self, frag: &'bump VFragment<'bump>) {
self.create_children_instructions(frag.children, MountType::Absorb);
self.stack.create_children(frag.children, MountType::Absorb);
}
fn create_component_node(&mut self, vcomponent: &'bump VComponent<'bump>) {
let caller = vcomponent.caller.clone();
let parent_idx = self.scope_stack.last().unwrap().clone();
let parent_idx = self.stack.current_scope().unwrap();
// Insert a new scope into our component list
let new_idx = self.vdom.insert_scope_with_key(|new_idx| {
let parent_scope = self.get_scope(&parent_idx).unwrap();
let parent_scope = self.vdom.get_scope(parent_idx).unwrap();
let height = parent_scope.height + 1;
Scope::new(
caller,
@@ -384,7 +331,7 @@ impl<'bump> DiffMachine<'bump> {
vcomponent.ass_scope.set(Some(new_idx));
if !vcomponent.can_memoize {
let cur_scope = self.get_scope_mut(&parent_idx).unwrap();
let cur_scope = self.vdom.get_scope_mut(parent_idx).unwrap();
let extended = vcomponent as *const VComponent;
let extended: *const VComponent<'static> = unsafe { std::mem::transmute(extended) };
cur_scope.borrowed_props.borrow_mut().push(extended);
@@ -394,7 +341,7 @@ impl<'bump> DiffMachine<'bump> {
// add noderefs to current noderef list Noderefs
// add effects to current effect list Effects
let new_component = self.get_scope_mut(&new_idx).unwrap();
let new_component = self.vdom.get_scope_mut(new_idx).unwrap();
// Run the scope for one iteration to initialize it
match new_component.run_scope() {
@@ -411,16 +358,7 @@ impl<'bump> DiffMachine<'bump> {
// Take the node that was just generated from running the component
let nextnode = new_component.frames.fin_head();
// Push the new scope onto the stack
self.scope_stack.push(new_idx);
self.instructions.push(DiffInstruction::PopScope);
// Run the creation algorithm with this scope on the stack
// ?? I think we treat components as framgnets??
self.instructions.push(DiffInstruction::Create {
node: nextnode,
and: MountType::Absorb,
});
self.stack.create_component(new_idx, nextnode);
// Finally, insert this scope as a seen node.
self.seen_scopes.insert(new_idx);
@@ -445,7 +383,7 @@ impl<'bump> DiffMachine<'bump> {
(
Component(_) | Fragment(_) | Text(_) | Element(_) | Anchor(_) | Suspended(_),
Component(_) | Fragment(_) | Text(_) | Element(_) | Anchor(_) | Suspended(_),
) => self.replace_and_create_many_with_many(old_node, new_node),
) => self.replace_and_create_one_with_one(old_node, new_node),
}
}
@@ -517,7 +455,7 @@ impl<'bump> DiffMachine<'bump> {
// We also need to make sure that all listeners are properly attached to the parent scope (fix_listener)
//
// TODO: take a more efficient path than this
let cur_scope: ScopeId = self.scope_stack.last().unwrap().clone();
let cur_scope = self.stack.current_scope().unwrap();
if old.listeners.len() == new.listeners.len() {
for (old_l, new_l) in old.listeners.iter().zip(new.listeners.iter()) {
if old_l.event != new_l.event {
@@ -559,13 +497,13 @@ impl<'bump> DiffMachine<'bump> {
// Make sure we're dealing with the same component (by function pointer)
if old.user_fc == new.user_fc {
//
self.scope_stack.push(scope_addr);
self.stack.scope_stack.push(scope_addr);
// Make sure the new component vnode is referencing the right scope id
new.ass_scope.set(Some(scope_addr));
// make sure the component's caller function is up to date
let scope = self.get_scope_mut(&scope_addr).unwrap();
let scope = self.vdom.get_scope_mut(scope_addr).unwrap();
scope.update_scope_dependencies(new.caller.clone(), ScopeChildren(new.children));
@@ -583,7 +521,7 @@ impl<'bump> DiffMachine<'bump> {
}
}
self.scope_stack.pop();
self.stack.scope_stack.pop();
self.seen_scopes.insert(scope_addr);
} else {
@@ -624,54 +562,6 @@ impl<'bump> DiffMachine<'bump> {
// Utilites for creating new diff instructions
// =============================================
fn create_children_instructions(
&mut self,
children: &'bump [VNode<'bump>],
and: MountType<'bump>,
) {
self.nodes_created_stack.push(0);
self.instructions.push(DiffInstruction::Mount { and });
for child in children.into_iter().rev() {
self.instructions.push(DiffInstruction::Create {
and: MountType::Absorb,
node: child,
});
}
}
/// Destroy a scope and all of its descendents.
///
/// Calling this will run the destuctors on all hooks in the tree.
/// It will also add the destroyed nodes to the `seen_nodes` cache to prevent them from being renderered.
fn destroy_scopes(&mut self, old_scope: ScopeId) {
let mut nodes_to_delete = vec![old_scope];
let mut scopes_to_explore = vec![old_scope];
// explore the scope tree breadth first
while let Some(scope_id) = scopes_to_explore.pop() {
// If we're planning on deleting this node, then we don't need to both rendering it
self.seen_scopes.insert(scope_id);
let scope = self.get_scope(&scope_id).unwrap();
for child in scope.descendents.borrow().iter() {
// Add this node to be explored
scopes_to_explore.push(child.clone());
// Also add it for deletion
nodes_to_delete.push(child.clone());
}
}
// Delete all scopes that we found as part of this subtree
for node in nodes_to_delete {
log::debug!("Removing scope {:#?}", node);
let _scope = self.vdom.try_remove(node).unwrap();
// do anything we need to do to delete the scope
// I think we need to run the destructors on the hooks
// TODO
}
}
// Diff the given set of old and new children.
//
// The parent must be on top of the change list stack when this function is
@@ -697,7 +587,7 @@ impl<'bump> DiffMachine<'bump> {
// Completely adding new nodes, removing any placeholder if it exists
(IS_EMPTY, IS_NOT_EMPTY) => {
self.create_children_instructions(new, MountType::Append);
self.stack.create_children(new, MountType::Append);
}
// Completely removing old nodes and putting an anchor in its place
@@ -705,7 +595,7 @@ impl<'bump> DiffMachine<'bump> {
// remove all the old nodes
(IS_NOT_EMPTY, IS_EMPTY) => {
for node in old {
self.remove_vnode(node);
self.remove_nodes(Some(node));
}
}
@@ -721,15 +611,13 @@ impl<'bump> DiffMachine<'bump> {
// Replace the anchor with whatever new nodes are coming down the pipe
(VNode::Anchor(anchor), _) => {
self.create_children_instructions(
new,
MountType::Replace { old: first_old },
);
self.stack
.create_children(new, MountType::Replace { old: first_old });
}
// Replace whatever nodes are sitting there with the anchor
(_, VNode::Anchor(anchor)) => {
self.replace_and_create_many_with_many(old, [first_new]);
self.replace_and_create_many_with_one(old, first_new);
}
// Use the complex diff algorithm to diff the nodes
@@ -884,7 +772,7 @@ impl<'bump> DiffMachine<'bump> {
// And if that was all of the new children, then remove all of the remaining
// old children and we're finished.
if shared_prefix_count == new.len() {
self.remove_children(&old[shared_prefix_count..]);
self.remove_nodes(&old[shared_prefix_count..]);
return KeyedPrefixResult::Finished;
}
@@ -898,7 +786,7 @@ impl<'bump> DiffMachine<'bump> {
// [... parent]
//
// When this function returns, the change list stack is in the same state.
pub fn create_and_append_children(&mut self, new: &'bump [VNode<'bump>]) {
fn create_and_append_children(&mut self, new: &'bump [VNode<'bump>]) {
for child in new {
todo!();
// let meta = self.create_vnode(child);
@@ -1069,7 +957,7 @@ impl<'bump> DiffMachine<'bump> {
self.mutations.insert_before(1);
}
} else {
self.instructions.push(DiffInstruction::Create {
self.stack.push(DiffInstruction::Create {
node: next_new,
and: MountType::InsertBefore {
other_node: Some(new_anchor),
@@ -1165,13 +1053,13 @@ impl<'bump> DiffMachine<'bump> {
Ordering::Greater => {
// Generate instructions to diff the existing elements
for (new_child, old_child) in new.iter().zip(old.iter()).rev() {
self.instructions.push(DiffInstruction::DiffNode {
self.stack.push(DiffInstruction::DiffNode {
new: new_child,
old: old_child,
});
}
self.instructions.push(DiffInstruction::RemoveChildren {
self.stack.push(DiffInstruction::RemoveChildren {
children: &old[new.len()..],
});
}
@@ -1183,14 +1071,14 @@ impl<'bump> DiffMachine<'bump> {
Ordering::Less => {
// Generate instructions to diff the existing elements
for (new_child, old_child) in new.iter().zip(old.iter()).rev() {
self.instructions.push(DiffInstruction::DiffNode {
self.stack.push(DiffInstruction::DiffNode {
new: new_child,
old: old_child,
});
}
// Generate instructions to add in the new elements
self.create_children_instructions(
self.stack.create_children(
&new[old.len()..],
MountType::InsertAfter {
other_node: old.last(),
@@ -1201,7 +1089,7 @@ impl<'bump> DiffMachine<'bump> {
// old.len == new.len -> no nodes added/removed, but perhaps changed
Ordering::Equal => {
for (new_child, old_child) in new.iter().zip(old.iter()).rev() {
self.instructions.push(DiffInstruction::DiffNode {
self.stack.push(DiffInstruction::DiffNode {
new: new_child,
old: old_child,
});
@@ -1210,40 +1098,6 @@ impl<'bump> DiffMachine<'bump> {
}
}
// ======================
// Support methods
// ======================
// // Remove all of a node's children.
// //
// // The change list stack must have this shape upon entry to this function:
// //
// // [... parent]
// //
// // When this function returns, the change list stack is in the same state.
// fn remove_all_children(&mut self, old: &'bump [VNode<'bump>]) {
// // debug_assert!(self.traversal_is_committed());
// log::debug!("REMOVING CHILDREN");
// for _child in old {
// // registry.remove_subtree(child);
// }
// // Fast way to remove all children: set the node's textContent to an empty
// // string.
// todo!()
// // self.set_inner_text("");
// }
// Remove the current child and all of its following siblings.
//
// The change list stack must have this shape upon entry to this function:
//
// [... parent child]
//
// After the function returns, the child is no longer on the change list stack:
//
// [... parent]
fn remove_children(&mut self, old: &'bump [VNode<'bump>]) {
self.replace_and_create_many_with_many(old, None)
}
fn find_last_element(&mut self, vnode: &'bump VNode<'bump>) -> &'bump VNode<'bump> {
let mut search_node = Some(vnode);
@@ -1260,7 +1114,7 @@ impl<'bump> DiffMachine<'bump> {
}
VNode::Component(el) => {
let scope_id = el.ass_scope.get().unwrap();
let scope = self.get_scope(&scope_id).unwrap();
let scope = self.vdom.get_scope(scope_id).unwrap();
search_node = Some(scope.root());
}
}
@@ -1283,7 +1137,7 @@ impl<'bump> DiffMachine<'bump> {
}
VNode::Component(el) => {
let scope_id = el.ass_scope.get().unwrap();
let scope = self.get_scope(&scope_id).unwrap();
let scope = self.vdom.get_scope(scope_id).unwrap();
search_node = Some(scope.root());
}
}
@@ -1294,56 +1148,107 @@ impl<'bump> DiffMachine<'bump> {
// self.replace_and_create_many_with_many(Some(node), None);
// }
fn replace_and_create_one_with_one(
&mut self,
old: &'bump VNode<'bump>,
new: &'bump VNode<'bump>,
) {
self.stack.create_node(new, MountType::Replace { old });
}
fn replace_many_with_many(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
//
}
fn replace_one_with_many(&mut self, old: &'bump VNode<'bump>, new: &'bump [VNode<'bump>]) {
//
self.stack.create_children(new, MountType::Replace { old });
}
/// Remove all the old nodes and replace them with newly created new nodes.
///
/// The new nodes *will* be created - don't create them yourself!
fn replace_and_create_many_with_many(
fn replace_and_create_many_with_one(
&mut self,
old_node: &'bump VNode<'bump>,
new_node: &'bump VNode<'bump>,
// old_nodes: impl IntoIterator<Item = &'bump VNode<'bump>>,
// new_nodes: impl IntoIterator<Item = &'bump VNode<'bump>>,
old: &'bump [VNode<'bump>],
new: &'bump VNode<'bump>,
) {
let mut nodes_to_replace = Vec::new();
let mut nodes_to_search = vec![old_node];
let mut scopes_obliterated = Vec::new();
while let Some(node) = nodes_to_search.pop() {
match &node {
// the ones that have a direct id return immediately
VNode::Text(el) => nodes_to_replace.push(el.dom_id.get().unwrap()),
VNode::Element(el) => nodes_to_replace.push(el.dom_id.get().unwrap()),
VNode::Anchor(el) => nodes_to_replace.push(el.dom_id.get().unwrap()),
VNode::Suspended(el) => nodes_to_replace.push(el.node.get().unwrap()),
if let Some(first_old) = old.get(0) {
self.remove_nodes(&old[1..]);
self.stack
.create_node(new, MountType::Replace { old: first_old });
} else {
self.stack.create_node(new, MountType::Append {});
}
}
// Fragments will either have a single anchor or a list of children
VNode::Fragment(frag) => {
for child in frag.children {
nodes_to_search.push(child);
}
/// schedules nodes for garbage collection and pushes "remove" to the mutation stack
/// remove can happen whenever
fn remove_nodes(&mut self, nodes: impl IntoIterator<Item = &'bump VNode<'bump>>) {
// or cache the vec on the diff machine
for node in nodes {
match node {
VNode::Text(t) => {
t.dom_id.get().map(|id| {
self.mutations.remove(id.as_u64());
self.vdom.collect_garbage(id);
});
}
// Components can be any of the nodes above
// However, we do need to track which components need to be removed
VNode::Component(el) => {
let scope_id = el.ass_scope.get().unwrap();
let scope = self.get_scope(&scope_id).unwrap();
VNode::Suspended(s) => {
s.node.get().map(|id| {
self.mutations.remove(id.as_u64());
self.vdom.collect_garbage(id);
});
}
VNode::Anchor(a) => {
a.dom_id.get().map(|id| {
self.mutations.remove(id.as_u64());
self.vdom.collect_garbage(id);
});
}
VNode::Element(e) => {
e.dom_id.get().map(|id| self.mutations.remove(id.as_u64()));
}
VNode::Fragment(f) => {
self.remove_nodes(f.children);
}
VNode::Component(c) => {
let scope_id = c.ass_scope.get().unwrap();
let scope = self.vdom.get_scope(scope_id).unwrap();
let root = scope.root();
nodes_to_search.push(root);
scopes_obliterated.push(scope_id);
self.remove_nodes(Some(root));
}
}
// TODO: enable internal garabge collection
// self.create_garbage(node);
}
// let mut nodes_to_replace = Vec::new();
// let mut nodes_to_search = vec![old_node];
// let mut scopes_obliterated = Vec::new();
// while let Some(node) = nodes_to_search.pop() {
// match &node {
// // the ones that have a direct id return immediately
// VNode::Text(el) => nodes_to_replace.push(el.dom_id.get().unwrap()),
// VNode::Element(el) => nodes_to_replace.push(el.dom_id.get().unwrap()),
// VNode::Anchor(el) => nodes_to_replace.push(el.dom_id.get().unwrap()),
// VNode::Suspended(el) => nodes_to_replace.push(el.node.get().unwrap()),
// // Fragments will either have a single anchor or a list of children
// VNode::Fragment(frag) => {
// for child in frag.children {
// nodes_to_search.push(child);
// }
// }
// // Components can be any of the nodes above
// // However, we do need to track which components need to be removed
// VNode::Component(el) => {
// let scope_id = el.ass_scope.get().unwrap();
// let scope = self.vdom.get_scope(scope_id).unwrap();
// let root = scope.root();
// nodes_to_search.push(root);
// scopes_obliterated.push(scope_id);
// }
// }
// // TODO: enable internal garabge collection
// // self.create_garbage(node);
// }
// let n = nodes_to_replace.len();
// for node in nodes_to_replace {
// self.mutations.push_root(node);
@@ -1365,13 +1270,37 @@ impl<'bump> DiffMachine<'bump> {
// });
// obliterate!
for scope in scopes_obliterated {
self.destroy_scopes(scope);
// for scope in scopes_obliterated {
// todo: mark as garbage
// self.destroy_scopes(scope);
// }
}
/// Remove all the old nodes and replace them with newly created new nodes.
///
/// The new nodes *will* be created - don't create them yourself!
fn replace_and_create_many_with_many(
&mut self,
old: &'bump [VNode<'bump>],
new: &'bump [VNode<'bump>],
) {
if let Some(first_old) = old.get(0) {
self.remove_nodes(&old[1..]);
self.stack
.create_children(new, MountType::Replace { old: first_old })
} else {
self.stack.create_children(new, MountType::Append {});
}
}
fn create_garbage(&mut self, node: &'bump VNode<'bump>) {
match self.current_scope().and_then(|id| self.get_scope(&id)) {
match self
.stack
.current_scope()
.and_then(|id| self.vdom.get_scope(id))
{
Some(scope) => {
let garbage: &'bump VNode<'static> = unsafe { std::mem::transmute(node) };
scope.pending_garbage.borrow_mut().push(garbage);
@@ -1382,92 +1311,26 @@ impl<'bump> DiffMachine<'bump> {
}
}
fn immediately_dispose_garabage(&mut self, node: ElementId) {
self.vdom.collect_garbage(node)
}
fn replace_node_with_node(
&mut self,
anchor: ElementId,
old_node: &'bump VNode<'bump>,
new_node: &'bump VNode<'bump>,
) {
self.mutations.push_root(anchor);
todo!();
// let meta = self.create_vnode(new_node);
// self.mutations.replace_with(1, meta.added_to_stack);
// self.create_garbage(old_node);
self.mutations.pop();
}
fn remove_vnode(&mut self, node: &'bump VNode<'bump>) {
match &node {
VNode::Text(el) => self.immediately_dispose_garabage(node.direct_id()),
VNode::Element(el) => {
self.immediately_dispose_garabage(node.direct_id());
for child in el.children {
self.remove_vnode(&child);
}
}
VNode::Anchor(a) => {
//
}
VNode::Fragment(frag) => {
for child in frag.children {
self.remove_vnode(&child);
}
}
VNode::Component(el) => {
//
// self.destroy_scopes(old_scope)
}
VNode::Suspended(_) => todo!(),
}
}
fn current_scope(&self) -> Option<ScopeId> {
self.scope_stack.last().map(|f| f.clone())
self.stack.instructions.push(DiffInstruction::Create {
and: MountType::Replace { old: old_node },
node: new_node,
});
}
fn fix_listener<'a>(&mut self, listener: &'a Listener<'a>) {
let scope_id = self.current_scope();
let scope_id = self.stack.current_scope();
if let Some(scope_id) = scope_id {
let scope = self.get_scope(&scope_id).unwrap();
let scope = self.vdom.get_scope(scope_id).unwrap();
let mut queue = scope.listeners.borrow_mut();
let long_listener: &'a Listener<'static> = unsafe { std::mem::transmute(listener) };
queue.push(long_listener as *const _)
}
}
pub fn get_scope_mut(&mut self, id: &ScopeId) -> Option<&'bump mut Scope> {
// ensure we haven't seen this scope before
// if we have, then we're trying to alias it, which is not allowed
debug_assert!(!self.seen_scopes.contains(id));
unsafe { self.vdom.get_scope_mut(*id) }
}
pub fn get_scope(&mut self, id: &ScopeId) -> Option<&'bump Scope> {
// ensure we haven't seen this scope before
// if we have, then we're trying to alias it, which is not allowed
unsafe { self.vdom.get_scope(*id) }
}
}
// When we create new nodes, we need to propagate some information back up the call chain.
// This gives the caller some information on how to handle things like insertins, appending, and subtree discarding.
#[derive(Debug)]
pub struct CreateMeta {
pub is_static: bool,
pub added_to_stack: u32,
}
impl CreateMeta {
fn new(is_static: bool, added_to_tack: u32) -> Self {
Self {
is_static,
added_to_stack: added_to_tack,
}
}
}
enum KeyedPrefixResult {
@@ -1478,156 +1341,3 @@ enum KeyedPrefixResult {
// the beginning of `new` and `old` we already processed.
MoreWorkToDo(usize),
}
fn find_first_real_node<'a>(
nodes: impl IntoIterator<Item = &'a VNode<'a>>,
scopes: &'a SharedResources,
) -> Option<&'a VNode<'a>> {
for node in nodes {
let mut iter = RealChildIterator::new(node, scopes);
if let Some(node) = iter.next() {
return Some(node);
}
}
None
}
/// This iterator iterates through a list of virtual children and only returns real children (Elements, Text, Anchors).
///
/// This iterator is useful when it's important to load the next real root onto the top of the stack for operations like
/// "InsertBefore".
pub struct RealChildIterator<'a> {
scopes: &'a SharedResources,
// Heuristcally we should never bleed into 4 completely nested fragments/components
// Smallvec lets us stack allocate our little stack machine so the vast majority of cases are sane
// TODO: use const generics instead of the 4 estimation
stack: smallvec::SmallVec<[(u16, &'a VNode<'a>); 4]>,
}
impl<'a> RealChildIterator<'a> {
pub fn new(starter: &'a VNode<'a>, scopes: &'a SharedResources) -> Self {
Self {
scopes,
stack: smallvec::smallvec![(0, starter)],
}
}
pub fn new_from_slice(nodes: &'a [VNode<'a>], scopes: &'a SharedResources) -> Self {
let mut stack = smallvec::smallvec![];
for node in nodes {
stack.push((0, node));
}
Self { scopes, stack }
}
// keep the memory around
pub fn reset_with(&mut self, node: &'a VNode<'a>) {
self.stack.clear();
self.stack.push((0, node));
}
}
impl<'a> Iterator for RealChildIterator<'a> {
type Item = &'a VNode<'a>;
fn next(&mut self) -> Option<&'a VNode<'a>> {
let mut should_pop = false;
let mut returned_node: Option<&'a VNode<'a>> = None;
let mut should_push = None;
while returned_node.is_none() {
if let Some((count, node)) = self.stack.last_mut() {
match &node {
// We can only exit our looping when we get "real" nodes
// This includes fragments and components when they're empty (have a single root)
VNode::Element(_) | VNode::Text(_) => {
// We've recursed INTO an element/text
// We need to recurse *out* of it and move forward to the next
should_pop = true;
returned_node = Some(&*node);
}
// If we get a fragment we push the next child
VNode::Fragment(frag) => {
let subcount = *count as usize;
if frag.children.len() == 0 {
should_pop = true;
returned_node = Some(&*node);
}
if subcount >= frag.children.len() {
should_pop = true;
} else {
should_push = Some(&frag.children[subcount]);
}
}
// // If we get a fragment we push the next child
// VNodeKind::Fragment(frag) => {
// let subcount = *count as usize;
// if frag.children.len() == 0 {
// should_pop = true;
// returned_node = Some(&*node);
// }
// if subcount >= frag.children.len() {
// should_pop = true;
// } else {
// should_push = Some(&frag.children[subcount]);
// }
// }
// Immediately abort suspended nodes - can't do anything with them yet
VNode::Suspended(node) => {
// VNodeKind::Suspended => should_pop = true,
todo!()
}
VNode::Anchor(a) => {
todo!()
}
// For components, we load their root and push them onto the stack
VNode::Component(sc) => {
let scope =
unsafe { self.scopes.get_scope(sc.ass_scope.get().unwrap()) }.unwrap();
// let scope = self.scopes.get(sc.ass_scope.get().unwrap()).unwrap();
// Simply swap the current node on the stack with the root of the component
*node = scope.frames.fin_head();
}
}
} else {
// If there's no more items on the stack, we're done!
return None;
}
if should_pop {
self.stack.pop();
if let Some((id, _)) = self.stack.last_mut() {
*id += 1;
}
should_pop = false;
}
if let Some(push) = should_push {
self.stack.push((0, push));
should_push = None;
}
}
returned_node
}
}
fn compare_strs(a: &str, b: &str) -> bool {
// Check by pointer, optimizing for static strs
if !std::ptr::eq(a, b) {
// If the pointers are different then check by value
a == b
} else {
true
}
}
packages/core/src/diff_stack.rs
+115
View File
@@ -0,0 +1,115 @@
use crate::innerlude::*;
use smallvec::{smallvec, SmallVec};
/// The stack instructions we use to diff and create new nodes.
#[derive(Debug)]
pub enum DiffInstruction<'a> {
DiffNode {
old: &'a VNode<'a>,
new: &'a VNode<'a>,
},
DiffChildren {
old: &'a [VNode<'a>],
new: &'a [VNode<'a>],
},
Create {
node: &'a VNode<'a>,
and: MountType<'a>,
},
Remove {
child: &'a VNode<'a>,
},
RemoveChildren {
children: &'a [VNode<'a>],
},
Mount {
and: MountType<'a>,
},
PopElement,
PopScope,
}
#[derive(Debug, Clone, Copy)]
pub enum MountType<'a> {
Absorb,
Append,
Replace { old: &'a VNode<'a> },
InsertAfter { other_node: Option<&'a VNode<'a>> },
InsertBefore { other_node: Option<&'a VNode<'a>> },
}
pub struct DiffStack<'bump> {
pub instructions: Vec<DiffInstruction<'bump>>,
pub nodes_created_stack: SmallVec<[usize; 10]>,
pub scope_stack: SmallVec<[ScopeId; 5]>,
}
impl<'bump> DiffStack<'bump> {
pub fn new(cur_scope: ScopeId) -> Self {
Self {
instructions: Vec::with_capacity(1000),
nodes_created_stack: smallvec![],
scope_stack: smallvec![cur_scope],
}
}
pub fn pop(&mut self) -> Option<DiffInstruction<'bump>> {
self.instructions.pop()
}
pub fn pop_scope(&mut self) -> Option<ScopeId> {
self.scope_stack.pop()
}
pub fn push(&mut self, instruction: DiffInstruction<'bump>) {
self.instructions.push(instruction)
}
pub fn create_children(&mut self, children: &'bump [VNode<'bump>], and: MountType<'bump>) {
self.nodes_created_stack.push(0);
self.instructions.push(DiffInstruction::Mount { and });
for child in children.into_iter().rev() {
self.instructions.push(DiffInstruction::Create {
and: MountType::Absorb,
node: child,
});
}
}
pub fn create_node(&mut self, node: &'bump VNode<'bump>, and: MountType<'bump>) {
self.nodes_created_stack.push(0);
self.instructions.push(DiffInstruction::Mount { and });
self.instructions
.push(DiffInstruction::Create { and, node });
}
pub fn add_child_count(&mut self, count: usize) {
*self.nodes_created_stack.last_mut().unwrap() += count;
}
pub fn current_scope(&self) -> Option<ScopeId> {
self.scope_stack.last().map(|f| f.clone())
}
pub fn create_component(&mut self, idx: ScopeId, node: &'bump VNode<'bump>) {
// Push the new scope onto the stack
self.scope_stack.push(idx);
self.instructions.push(DiffInstruction::PopScope);
// Run the creation algorithm with this scope on the stack
// ?? I think we treat components as framgnets??
self.instructions.push(DiffInstruction::Create {
node,
and: MountType::Absorb,
});
}
}
packages/core/src/diffsupport.rs
+72
View File
@@ -0,0 +1,72 @@
/// Destroy a scope and all of its descendents.
///
/// Calling this will run the destuctors on all hooks in the tree.
/// It will also add the destroyed nodes to the `seen_nodes` cache to prevent them from being renderered.
fn destroy_scopes(&mut self, old_scope: ScopeId) {
let mut nodes_to_delete = vec![old_scope];
let mut scopes_to_explore = vec![old_scope];
// explore the scope tree breadth first
while let Some(scope_id) = scopes_to_explore.pop() {
// If we're planning on deleting this node, then we don't need to both rendering it
self.seen_scopes.insert(scope_id);
let scope = self.get_scope(&scope_id).unwrap();
for child in scope.descendents.borrow().iter() {
// Add this node to be explored
scopes_to_explore.push(child.clone());
// Also add it for deletion
nodes_to_delete.push(child.clone());
}
}
// Delete all scopes that we found as part of this subtree
for node in nodes_to_delete {
log::debug!("Removing scope {:#?}", node);
let _scope = self.vdom.try_remove(node).unwrap();
// do anything we need to do to delete the scope
// I think we need to run the destructors on the hooks
// TODO
}
}
pub(crate) fn get_scope_mut(&mut self, id: &ScopeId) -> Option<&'bump mut Scope> {
// ensure we haven't seen this scope before
// if we have, then we're trying to alias it, which is not allowed
debug_assert!(!self.seen_scopes.contains(id));
unsafe { self.vdom.get_scope_mut(*id) }
}
pub(crate) fn get_scope(&mut self, id: &ScopeId) -> Option<&'bump Scope> {
// ensure we haven't seen this scope before
// if we have, then we're trying to alias it, which is not allowed
unsafe { self.vdom.get_scope(*id) }
}
fn compare_strs(a: &str, b: &str) -> bool {
// Check by pointer, optimizing for static strs
if !std::ptr::eq(a, b) {
// If the pointers are different then check by value
a == b
} else {
true
}
}
fn find_first_real_node<'a>(
nodes: impl IntoIterator<Item = &'a VNode<'a>>,
scopes: &'a SharedResources,
) -> Option<&'a VNode<'a>> {
for node in nodes {
let mut iter = RealChildIterator::new(node, scopes);
if let Some(node) = iter.next() {
return Some(node);
}
}
None
}
fn remove_children(&mut self, old: &'bump [VNode<'bump>]) {
self.replace_and_create_many_with_many(old, None)
}
packages/core/src/editor.rs
+5 -6
View File
@@ -24,10 +24,6 @@ pub enum DomEdit<'bump> {
many: u32,
},
ReplaceWith {
// the first n elements
n: u32,
// the last m elements
m: u32,
},
InsertAfter {
@@ -36,7 +32,10 @@ pub enum DomEdit<'bump> {
InsertBefore {
n: u32,
},
Remove,
// remove roots directly
Remove {
root: u64,
},
RemoveAllChildren,
CreateTextNode {
text: &'bump str,
@@ -83,7 +82,7 @@ impl DomEdit<'_> {
DomEdit::PopRoot => id == "PopRoot",
DomEdit::AppendChildren { .. } => id == "AppendChildren",
DomEdit::ReplaceWith { .. } => id == "ReplaceWith",
DomEdit::Remove => id == "Remove",
DomEdit::Remove { .. } => id == "Remove",
DomEdit::RemoveAllChildren => id == "RemoveAllChildren",
DomEdit::CreateTextNode { .. } => id == "CreateTextNode",
DomEdit::CreateElement { .. } => id == "CreateElement",
packages/core/src/lib.rs
+4
View File
@@ -30,9 +30,11 @@ pub mod prelude {
pub(crate) mod innerlude {
pub use crate::arena::*;
pub use crate::bumpframe::*;
pub use crate::childiter::*;
pub use crate::component::*;
pub use crate::context::*;
pub use crate::diff::*;
pub use crate::diff_stack::*;
pub use crate::editor::*;
pub use crate::error::*;
pub use crate::events::*;
@@ -60,9 +62,11 @@ pub mod exports {
pub mod arena;
pub mod bumpframe;
pub mod childiter;
pub mod component;
pub mod context;
pub mod diff;
pub mod diff_stack;
pub mod editor;
pub mod error;
pub mod events;
packages/core/src/mutations.rs
+27 -17
View File
@@ -1,17 +1,18 @@
use std::any::Any;
//! Instructions returned by the VirtualDOM on how to modify the Real DOM.
//!
use crate::innerlude::*;
use std::any::Any;
/// The "Mutations" object holds the changes that need to be made to the DOM.
///
#[derive(Debug)]
pub struct Mutations<'s> {
pub edits: Vec<DomEdit<'s>>,
pub noderefs: Vec<NodeRefMutation<'s>>,
pub struct Mutations<'a> {
pub edits: Vec<DomEdit<'a>>,
pub noderefs: Vec<NodeRefMutation<'a>>,
}
use DomEdit::*;
impl<'bump> Mutations<'bump> {
impl<'a> Mutations<'a> {
pub fn new() -> Self {
let edits = Vec::new();
let noderefs = Vec::new();
@@ -25,29 +26,34 @@ impl<'bump> Mutations<'bump> {
let id = root.as_u64();
self.edits.push(PushRoot { id });
}
pub(crate) fn pop(&mut self) {
self.edits.push(PopRoot {});
}
// replace the n-m node on the stack with the m nodes
// ends with the last element of the chain on the top of the stack
pub(crate) fn replace_with(&mut self, n: u32, m: u32) {
self.edits.push(ReplaceWith { n, m });
pub(crate) fn replace_with(&mut self, m: u32) {
self.edits.push(ReplaceWith { m });
}
pub(crate) fn insert_after(&mut self, n: u32) {
self.edits.push(InsertAfter { n });
}
pub(crate) fn insert_before(&mut self, n: u32) {
self.edits.push(InsertBefore { n });
}
// Remove Nodesfrom the dom
pub(crate) fn remove(&mut self) {
self.edits.push(Remove);
pub(crate) fn remove(&mut self, id: u64) {
self.edits.push(Remove { root: id });
}
// Create
pub(crate) fn create_text_node(&mut self, text: &'bump str, id: ElementId) {
pub(crate) fn create_text_node(&mut self, text: &'a str, id: ElementId) {
let id = id.as_u64();
self.edits.push(CreateTextNode { text, id });
}
pub(crate) fn create_element(
&mut self,
tag: &'static str,
@@ -65,6 +71,7 @@ impl<'bump> Mutations<'bump> {
let id = id.as_u64();
self.edits.push(CreatePlaceholder { id });
}
// events
pub(crate) fn new_event_listener(&mut self, listener: &Listener, scope: ScopeId) {
let Listener {
@@ -84,11 +91,13 @@ impl<'bump> Mutations<'bump> {
pub(crate) fn remove_event_listener(&mut self, event: &'static str) {
self.edits.push(RemoveEventListener { event });
}
// modify
pub(crate) fn set_text(&mut self, text: &'bump str) {
pub(crate) fn set_text(&mut self, text: &'a str) {
self.edits.push(SetText { text });
}
pub(crate) fn set_attribute(&mut self, attribute: &'bump Attribute) {
pub(crate) fn set_attribute(&mut self, attribute: &'a Attribute) {
let Attribute {
name,
value,
@@ -103,7 +112,7 @@ impl<'bump> Mutations<'bump> {
ns: *namespace,
});
}
pub(crate) fn set_attribute_ns(&mut self, attribute: &'bump Attribute, namespace: &'bump str) {
pub(crate) fn set_attribute_ns(&mut self, attribute: &'a Attribute, namespace: &'a str) {
let Attribute {
name,
value,
@@ -118,6 +127,7 @@ impl<'bump> Mutations<'bump> {
ns: Some(namespace),
});
}
pub(crate) fn remove_attribute(&mut self, attribute: &Attribute) {
let name = attribute.name;
self.edits.push(RemoveAttribute { name });
packages/core/src/nodes.rs
-10
View File
@@ -98,13 +98,8 @@ pub struct VElement<'a> {
pub namespace: Option<&'static str>,
pub dom_id: Cell<Option<ElementId>>,
pub static_listeners: bool,
pub listeners: &'a [Listener<'a>],
pub static_attrs: bool,
pub attributes: &'a [Attribute<'a>],
pub static_children: bool,
pub children: &'a [VNode<'a>],
}
@@ -303,11 +298,6 @@ impl<'a> NodeFactory<'a> {
attributes,
children,
dom_id: empty_cell(),
// todo: wire up more constization
static_listeners: false,
static_attrs: false,
static_children: false,
}))
}
packages/core/src/virtual_dom.rs
+8 -6
View File
@@ -166,13 +166,14 @@ impl VirtualDom {
pub async fn rebuild_async<'s>(&'s mut self) -> Result<Mutations<'s>> {
let mut diff_machine = DiffMachine::new(Mutations::new(), self.base_scope, &self.shared);
let cur_component = diff_machine
.get_scope_mut(&self.base_scope)
let cur_component = self
.shared
.get_scope_mut(self.base_scope)
.expect("The base scope should never be moved");
// // We run the component. If it succeeds, then we can diff it and add the changes to the dom.
if cur_component.run_scope().is_ok() {
diff_machine.instructions.push(DiffInstruction::Create {
diff_machine.stack.push(DiffInstruction::Create {
node: cur_component.frames.fin_head(),
and: MountType::Append,
});
@@ -192,13 +193,14 @@ impl VirtualDom {
pub async fn diff_async<'s>(&'s mut self) -> Result<Mutations<'s>> {
let mut diff_machine = DiffMachine::new(Mutations::new(), self.base_scope, &self.shared);
let cur_component = diff_machine
.get_scope_mut(&self.base_scope)
let cur_component = self
.shared
.get_scope_mut(self.base_scope)
.expect("The base scope should never be moved");
cur_component.run_scope().unwrap();
diff_machine.instructions.push(DiffInstruction::DiffNode {
diff_machine.stack.push(DiffInstruction::DiffNode {
old: cur_component.frames.wip_head(),
new: cur_component.frames.fin_head(),
});
packages/core/tests/diffing.rs
+11 -17
View File
@@ -9,7 +9,7 @@ use bumpalo::Bump;
use anyhow::{Context, Result};
use dioxus::{
arena::SharedResources,
diff::{CreateMeta, DiffInstruction, DiffMachine},
diff::{DiffInstruction, DiffMachine},
prelude::*,
DomEdit,
};
@@ -44,7 +44,7 @@ impl TestDom {
let mut machine = DiffMachine::new_headless(&self.resources);
machine
.instructions
.stack
.push(dioxus::diff::DiffInstruction::DiffNode { new, old });
machine.mutations
@@ -58,12 +58,10 @@ impl TestDom {
let mut machine = DiffMachine::new_headless(&self.resources);
machine
.instructions
.push(dioxus::diff::DiffInstruction::Create {
node: old,
and: dioxus::diff::MountType::Append,
});
machine.stack.push(dioxus::diff::DiffInstruction::Create {
node: old,
and: dioxus::diff::MountType::Append,
});
work_sync(&mut machine);
machine.mutations
@@ -85,19 +83,15 @@ impl TestDom {
// let mut create_edits = Vec::new();
let mut machine = DiffMachine::new_headless(&self.resources);
machine
.instructions
.push(dioxus::diff::DiffInstruction::Create {
and: dioxus::diff::MountType::Append,
node: old,
});
machine.stack.push(dioxus::diff::DiffInstruction::Create {
and: dioxus::diff::MountType::Append,
node: old,
});
work_sync(&mut machine);
let create_edits = machine.mutations;
let mut machine = DiffMachine::new_headless(&self.resources);
machine
.instructions
.push(DiffInstruction::DiffNode { old, new });
machine.stack.push(DiffInstruction::DiffNode { old, new });
work_sync(&mut machine);
let edits = machine.mutations;