>>,
}
@@ -399,7 +408,7 @@ impl AnyProps for VComponentProps
{
}
// Safety:
- // this will downcat the other ptr as our swallowed type!
+ // this will downcast the other ptr as our swallowed type!
// you *must* make this check *before* calling this method
// if your functions are not the same, then you will downcast a pointer into a different type (UB)
unsafe fn memoize(&self, other: &dyn AnyProps) -> bool {
@@ -542,6 +551,7 @@ impl<'a> NodeFactory<'a> {
component: fn(Scope<'a, P>) -> Element,
props: P,
key: Option,
+ fn_name: &'static str,
) -> VNode<'a>
where
P: Properties + 'a,
@@ -550,8 +560,9 @@ impl<'a> NodeFactory<'a> {
key: key.map(|f| self.raw_text(f).0),
scope: Default::default(),
can_memoize: P::IS_STATIC,
- user_fc: component as *const (),
+ user_fc: component as ComponentPtr,
originator: self.scope.scope_id(),
+ fn_name,
props: RefCell::new(Some(Box::new(VComponentProps {
// local_props: RefCell::new(Some(props)),
// heap_props: RefCell::new(None),
diff --git a/packages/core/src/scopes.rs b/packages/core/src/scopes.rs
index cfc555543..00c3024bf 100644
--- a/packages/core/src/scopes.rs
+++ b/packages/core/src/scopes.rs
@@ -13,7 +13,9 @@ use std::{
rc::Rc,
};
-pub(crate) type FcSlot = *const ();
+/// for traceability, we use the raw fn pointer to identify the function
+/// we also get the component name, but that's not necessarily unique in the app
+pub(crate) type ComponentPtr = *mut std::os::raw::c_void;
pub(crate) struct Heuristic {
hook_arena_size: usize,
@@ -28,7 +30,7 @@ pub(crate) struct ScopeArena {
pub scope_gen: Cell,
pub bump: Bump,
pub scopes: RefCell>,
- pub heuristics: RefCell>,
+ pub heuristics: RefCell>,
pub free_scopes: RefCell>,
pub nodes: RefCell>>,
pub tasks: Rc,
@@ -70,7 +72,7 @@ impl ScopeArena {
}
/// Safety:
- /// - Obtaining a mutable refernece to any Scope is unsafe
+ /// - Obtaining a mutable reference to any Scope is unsafe
/// - Scopes use interior mutability when sharing data into components
pub(crate) fn get_scope(&self, id: ScopeId) -> Option<&ScopeState> {
unsafe { self.scopes.borrow().get(&id).map(|f| &**f) }
@@ -82,7 +84,7 @@ impl ScopeArena {
pub(crate) fn new_with_key(
&self,
- fc_ptr: *const (),
+ fc_ptr: ComponentPtr,
vcomp: Box,
parent_scope: Option,
container: ElementId,
@@ -94,14 +96,14 @@ impl ScopeArena {
// Get the height of the scope
let height = parent_scope
- .map(|id| self.get_scope(id).map(|scope| scope.height))
+ .map(|id| self.get_scope(id).map(|scope| scope.height + 1))
.flatten()
.unwrap_or_default();
let parent_scope = parent_scope.map(|f| self.get_scope_raw(f)).flatten();
/*
- This scopearena aggressively reuse old scopes when possible.
+ This scopearena aggressively reuses old scopes when possible.
We try to minimize the new allocations for props/arenas.
However, this will probably lead to some sort of fragmentation.
@@ -110,31 +112,62 @@ impl ScopeArena {
if let Some(old_scope) = self.free_scopes.borrow_mut().pop() {
// reuse the old scope
let scope = unsafe { &mut *old_scope };
- scope.props.get_mut().replace(vcomp);
+
+ scope.container = container;
+ scope.our_arena_idx = new_scope_id;
scope.parent_scope = parent_scope;
scope.height = height;
+ scope.fnptr = fc_ptr;
+ scope.props.get_mut().replace(vcomp);
scope.subtree.set(subtree);
- scope.our_arena_idx = new_scope_id;
- scope.container = container;
+ scope.frames[0].reset();
+ scope.frames[1].reset();
+ scope.shared_contexts.get_mut().clear();
+ scope.items.get_mut().listeners.clear();
+ scope.items.get_mut().borrowed_props.clear();
+ scope.hook_idx.set(0);
+ scope.hook_vals.get_mut().clear();
+
let any_item = self.scopes.borrow_mut().insert(new_scope_id, scope);
debug_assert!(any_item.is_none());
} else {
// else create a new scope
+ let (node_capacity, hook_capacity) = self
+ .heuristics
+ .borrow()
+ .get(&fc_ptr)
+ .map(|h| (h.node_arena_size, h.hook_arena_size))
+ .unwrap_or_default();
+
self.scopes.borrow_mut().insert(
new_scope_id,
- self.bump.alloc(ScopeState::new(
- height,
+ self.bump.alloc(ScopeState {
container,
- new_scope_id,
+ our_arena_idx: new_scope_id,
parent_scope,
- vcomp,
- self.tasks.clone(),
- self.heuristics
- .borrow()
- .get(&fc_ptr)
- .map(|h| (h.node_arena_size, h.hook_arena_size))
- .unwrap_or_default(),
- )),
+ height,
+ fnptr: fc_ptr,
+ props: RefCell::new(Some(vcomp)),
+ frames: [BumpFrame::new(node_capacity), BumpFrame::new(node_capacity)],
+
+ // todo: subtrees
+ subtree: Cell::new(0),
+ is_subtree_root: Cell::new(false),
+
+ generation: 0.into(),
+
+ tasks: self.tasks.clone(),
+ shared_contexts: Default::default(),
+
+ items: RefCell::new(SelfReferentialItems {
+ listeners: Default::default(),
+ borrowed_props: Default::default(),
+ }),
+
+ hook_arena: Bump::new(),
+ hook_vals: RefCell::new(Vec::with_capacity(hook_capacity)),
+ hook_idx: Default::default(),
+ }),
);
}
@@ -189,8 +222,6 @@ impl ScopeArena {
/// This also makes sure that drop order is consistent and predictable. All resources that rely on being dropped will
/// be dropped.
pub(crate) fn ensure_drop_safety(&self, scope_id: ScopeId) {
- log::trace!("Ensuring drop safety for scope {:?}", scope_id);
-
if let Some(scope) = self.get_scope(scope_id) {
let mut items = scope.items.borrow_mut();
@@ -201,7 +232,6 @@ impl ScopeArena {
if let Some(scope_id) = comp.scope.get() {
self.ensure_drop_safety(scope_id);
}
-
drop(comp.props.take());
});
@@ -217,18 +247,18 @@ impl ScopeArena {
// Cycle to the next frame and then reset it
// This breaks any latent references, invalidating every pointer referencing into it.
// Remove all the outdated listeners
- log::trace!("Running scope {:?}", id);
self.ensure_drop_safety(id);
// todo: we *know* that this is aliased by the contents of the scope itself
let scope = unsafe { &mut *self.get_scope_raw(id).expect("could not find scope") };
+ log::trace!("running scope {:?} symbol: {:?}", id, scope.fnptr);
+
// Safety:
// - We dropped the listeners, so no more &mut T can be used while these are held
// - All children nodes that rely on &mut T are replaced with a new reference
scope.hook_idx.set(0);
- // book keeping to ensure safety around the borrowed data
{
// Safety:
// - We've dropped all references to the wip bump frame with "ensure_drop_safety"
@@ -241,8 +271,6 @@ impl ScopeArena {
debug_assert!(items.borrowed_props.is_empty());
}
- // safety: this is definitely not dropped
-
/*
If the component returns None, then we fill in a placeholder node. This will wipe what was there.
An alternate approach is to leave the Real Dom the same, but that can lead to safety issues and a lot more checks.
@@ -284,14 +312,13 @@ impl ScopeArena {
while let Some(id) = cur_el.take() {
if let Some(el) = nodes.get(id.0) {
- log::trace!("Found valid receiver element");
-
let real_el = unsafe { &**el };
+ log::debug!("looking for listener on {:?}", real_el);
+
if let VNode::Element(real_el) = real_el {
for listener in real_el.listeners.borrow().iter() {
if listener.event == event.name {
- log::trace!("Found valid receiver event");
-
+ log::debug!("calling listener {:?}", listener.event);
if state.canceled.get() {
// stop bubbling if canceled
break;
@@ -421,6 +448,7 @@ pub struct ScopeState {
pub(crate) container: ElementId,
pub(crate) our_arena_idx: ScopeId,
pub(crate) height: u32,
+ pub(crate) fnptr: ComponentPtr,
// todo: subtrees
pub(crate) is_subtree_root: Cell,
@@ -449,43 +477,6 @@ pub struct SelfReferentialItems<'a> {
// Public methods exposed to libraries and components
impl ScopeState {
- fn new(
- height: u32,
- container: ElementId,
- our_arena_idx: ScopeId,
- parent_scope: Option<*mut ScopeState>,
- vcomp: Box,
- tasks: Rc,
- (node_capacity, hook_capacity): (usize, usize),
- ) -> Self {
- ScopeState {
- container,
- our_arena_idx,
- parent_scope,
- height,
- props: RefCell::new(Some(vcomp)),
- frames: [BumpFrame::new(node_capacity), BumpFrame::new(node_capacity)],
-
- // todo: subtrees
- subtree: Cell::new(0),
- is_subtree_root: Cell::new(false),
-
- generation: 0.into(),
-
- tasks,
- shared_contexts: Default::default(),
-
- items: RefCell::new(SelfReferentialItems {
- listeners: Default::default(),
- borrowed_props: Default::default(),
- }),
-
- hook_arena: Bump::new(),
- hook_vals: RefCell::new(Vec::with_capacity(hook_capacity)),
- hook_idx: Default::default(),
- }
- }
-
/// Get the subtree ID that this scope belongs to.
///
/// Each component has its own subtree ID - the root subtree has an ID of 0. This ID is used by the renderer to route
@@ -695,6 +686,7 @@ impl ScopeState {
.insert(TypeId::of::(), value.clone())
.map(|f| f.downcast::().ok())
.flatten();
+ return value;
}
let mut search_parent = self.parent_scope;
@@ -750,6 +742,11 @@ impl ScopeState {
self.tasks.push_fut(fut)
}
+ /// Spawns the future but does not return the TaskId
+ pub fn spawn(&self, fut: impl Future
