Scope 与 hooks

pub struct ScopeState {
    pub(crate) runtime: Rc<Runtime>,
    pub(crate) context_id: ScopeId,
    /// The last node that has been rendered for this component. This node may not ben mounted
    /// During suspense, this component can be rendered in the background multiple times
    pub(crate) last_rendered_node: Option<LastRenderedNode>,
    pub(crate) props: BoxedAnyProps,
    pub(crate) reactive_context: ReactiveContext,
}

pub(crate) struct Scope {
    pub(crate) name: &'static str,
    pub(crate) id: ScopeId,
    pub(crate) parent_id: Option<ScopeId>,
    pub(crate) height: u32,
    pub(crate) render_count: Cell<usize>,

    // Note: the order of the hook and context fields is important. The hooks field must be dropped before the contexts field in case a hook drop implementation tries to access a context.
    pub(crate) hooks: RefCell<Vec<Box<dyn Any>>>,
    pub(crate) hook_index: Cell<usize>,
    pub(crate) shared_contexts: RefCell<Vec<Box<dyn Any>>>,
    pub(crate) spawned_tasks: RefCell<FxHashSet<Task>>,
    pub(crate) before_render: RefCell<Vec<Box<dyn FnMut()>>>,
    pub(crate) after_render: RefCell<Vec<Box<dyn FnMut()>>>,

    /// The suspense boundary that this scope is currently in (if any)
    suspense_boundary: SuspenseLocation,

    pub(crate) status: RefCell<ScopeStatus>,
}

    pub(super) fn new_scope(
        &mut self,
        props: BoxedAnyProps,
        name: &'static str,
    ) -> &mut ScopeState {
        let parent_id = self.runtime.try_current_scope_id();
        let height = match parent_id.and_then(|id| self.runtime.try_get_state(id)) {
            Some(parent) => parent.height() + 1,
            None => 0,
        };
        let suspense_boundary = self
            .runtime
            .current_suspense_location()
            .unwrap_or(SuspenseLocation::NotSuspended);
        let entry = self.scopes.vacant_entry();
        let id = ScopeId(entry.key());

        let scope_runtime = Scope::new(name, id, parent_id, height, suspense_boundary);
        let reactive_context = ReactiveContext::new_for_scope(&scope_runtime, &self.runtime);

        let scope = entry.insert(ScopeState {
            runtime: self.runtime.clone(),
            context_id: id,
            props,
            last_rendered_node: Default::default(),
            reactive_context,
        });

        self.runtime.create_scope(scope_runtime);

        scope
    }

    pub(crate) fn run_scope(&mut self, scope_id: ScopeId) -> Element {
        // Ensure we are currently inside a `Runtime`.
        crate::Runtime::current();

        self.runtime.clone().with_scope_on_stack(scope_id, || {
            let scope = &self.scopes[scope_id.0];
            let output = {
                let scope_state = scope.state();

                scope_state.hook_index.set(0);

                // Run all pre-render hooks
                for pre_run in scope_state.before_render.borrow_mut().iter_mut() {
                    pre_run();
                }

                let props: &dyn AnyProps = &*scope.props;

                let span = tracing::trace_span!("render", scope = %scope.state().name);
                span.in_scope(|| {
                    scope.reactive_context.reset_and_run_in(|| {
                        let render_return = props.render();
                        // After the component is run, we need to do a deep clone of the VNode. This
                        // breaks any references to mounted parts of the VNode from the component.
                        // ...
                        let mut render_return = match render_return {
                            Ok(node) => Ok(node.deep_clone()),
                            Err(RenderError::Error(err)) => Err(RenderError::Error(err.clone())),
                            Err(RenderError::Suspended(fut)) => {
                                Err(RenderError::Suspended(fut.deep_clone()))
                            }
                        };

                        self.handle_element_return(&mut render_return, &scope.state());
                        render_return
                    })
                })
            };

            let scope_state = scope.state();

            // Run all post-render hooks
            for post_run in scope_state.after_render.borrow_mut().iter_mut() {
                post_run();
            }

            // remove this scope from dirty scopes
            self.dirty_scopes
                .remove(&ScopeOrder::new(scope_state.height, scope_id));
            output
        })
    }

    pub(crate) fn use_hook<State: Clone + 'static>(
        &self,
        initializer: impl FnOnce() -> State,
    ) -> State {
        let cur_hook = self.hook_index.get();

        // The hook list works by keeping track of the current hook index and pushing the index forward
        // while retrieving the hook value.
        self.hook_index.set(cur_hook + 1);

        let mut hooks = self.hooks
            .try_borrow_mut()
            .expect("The hook list is already borrowed: This error is likely caused by trying to use  hook inside a hook which violates the rules of hooks.");

        // Try and retrieve the hook value if it exists
        if let Some(existing) = self.use_hook_inner::<State>(&mut hooks, cur_hook) {
            return existing;
        }

        // Otherwise, initialize the hook value. In debug mode, we allow hook types to change after a hot patch
        self.push_hook_value(&mut hooks, cur_hook, initializer())
    }

    // The interior version that gets monomorphized by the `State` type but not the `initializer` type.
    // This helps trim down binary sizes
    fn use_hook_inner<State: Clone + 'static>(
        &self,
        hooks: &mut Vec<Box<dyn std::any::Any>>,
        cur_hook: usize,
    ) -> Option<State> {
        hooks.get(cur_hook).and_then(|inn| {
            let raw_ref: &dyn Any = inn.as_ref();
            raw_ref.downcast_ref::<State>().cloned()
        })
    }

    fn push_hook_value<State: Clone + 'static>(
        &self,
        hooks: &mut Vec<Box<dyn std::any::Any>>,
        cur_hook: usize,
        value: State,
    ) -> State {
        // If this is a new hook, push it
        if cur_hook >= hooks.len() {
            hooks.push(Box::new(value.clone()));
            return value;
        }

        // If we're in dev mode, we allow swapping hook values if the hook was initialized at this index
        if cfg!(debug_assertions) && unsafe { subsecond::get_jump_table().is_some() } {
            hooks[cur_hook] = Box::new(value.clone());
            return value;
        }

        // Otherwise, panic
        panic!(
            r#"Unable to retrieve the hook that was initialized at this index.
                    Consult the `rules of hooks` to understand how to use hooks properly.

                    You likely used the hook in a conditional. Hooks rely on consistent ordering between renders.
                    Functions prefixed with "use" should never be called conditionally.

                    Help: Run `dx check` to look for check for some common hook errors."#
        );
    }

fn app() -> Element {
  let flag = FLAG.with(|f| f.get());
  match CASE.with(|c| c.get()) {
    // A: the conditional hook has a different type from the next one
    0 => {
      if flag {
        let s = use_signal(|| "text".to_string());
        println!("  [A] s = {s}");
      }
      let n = use_signal(|| 7i32);
      println!("  [A] n = {n}");
      rsx! { "n = {n}" }
    }
    // B: both hooks are Signal<i32>
    1 => {
      if flag {
        let a = use_signal(|| 1i32);
        println!("  [B] a = {a}");
      }
      let b = use_signal(|| 2i32);
      println!("  [B] b = {b}");
      rsx! { "b = {b}" }
    }
    // C: the conditional hook is the last one
    _ => {
      let b = use_signal(|| 2i32);
      if flag {
        let a = use_signal(|| 1i32);
        println!("  [C] a = {a}");
      }
      println!("  [C] b = {b}");
      rsx! { "b = {b}" }
    }
  }
}

fn run(case: u8, flags: &[bool]) {
  CASE.with(|c| c.set(case));
  FLAG.with(|f| f.set(flags[0]));
  let mut dom = VirtualDom::new(app);
  println!("render 1 (flag = {})", flags[0]);
  dom.rebuild_in_place();
  println!("  html: {}", dioxus_ssr::render(&dom));
  for (i, &flag) in flags.iter().enumerate().skip(1) {
    FLAG.with(|f| f.set(flag));
    println!("render {} (flag = {flag})", i + 1);
    dom.mark_dirty(ScopeId::APP);
    dom.render_immediate_to_vec();
    println!("  html: {}", dioxus_ssr::render(&dom));
  }
  let edits = dom.render_immediate_to_vec();
  println!("one more render_immediate, nothing marked dirty: {} edits", edits.edits.len());
  println!("  html: {}", dioxus_ssr::render(&dom));
}

fn main() {
  println!("== case A: String hook skipped, then i32 hook");
  run(0, &[true, false]);
  println!("== case B: i32 hook skipped, then i32 hook");
  run(1, &[true, false]);
  println!("== case C: conditional hook at the end");
  run(2, &[false, true, false, true]);
}

== case A: String hook skipped, then i32 hook
render 1 (flag = true)
  [A] s = text
  [A] n = 7
  html: n = 7
render 2 (flag = false)

thread 'main' (1057674) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dioxus-core-0.7.10/src/scope_context.rs:387:9:
Unable to retrieve the hook that was initialized at this index.
                    Consult the `rules of hooks` to understand how to use hooks properly.

                    You likely used the hook in a conditional. Hooks rely on consistent ordering between renders.
                    Functions prefixed with "use" should never be called conditionally.

                    Help: Run `dx check` to look for check for some common hook errors.
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
  html: n = 7
one more render_immediate, nothing marked dirty: 6 edits
  html: <div style="color:red;"><pre>Encountered panic: Any { .. }</pre></div>
== case B: i32 hook skipped, then i32 hook
render 1 (flag = true)
  [B] a = 1
  [B] b = 2
  html: b = 2
render 2 (flag = false)
  [B] b = 1
  html: b = 1
one more render_immediate, nothing marked dirty: 0 edits
  html: b = 1
== case C: conditional hook at the end
render 1 (flag = false)
  [C] b = 2
  html: b = 2
render 2 (flag = true)
  [C] a = 1
  [C] b = 2
  html: b = 2
render 3 (flag = false)
  [C] b = 2
  html: b = 2
render 4 (flag = true)
  [C] a = 1
  [C] b = 2
  html: b = 2
one more render_immediate, nothing marked dirty: 0 edits
  html: b = 2

    pub(crate) fn provide_context<T: 'static + Clone>(&self, value: T) -> T {
        let mut contexts = self.shared_contexts.borrow_mut();

        // If the context exists, swap it out for the new value
        for ctx in contexts.iter_mut() {
            // Swap the ptr directly
            if let Some(ctx) = ctx.downcast_mut::<T>() {
                *ctx = value.clone();
                return value;
            }
        }

        // Else, just push it
        contexts.push(Box::new(value.clone()));

        value
    }

    pub(crate) fn consume_context<T: 'static + Clone>(&self) -> Option<T> {
        if let Some(this_ctx) = self.has_context::<T>() {
            return Some(this_ctx);
        }

        let mut search_parent = self.parent_id;

        Runtime::with(|runtime| {
            while let Some(parent_id) = search_parent {
                let parent = runtime.try_get_state(parent_id)?;
                if let Some(shared) = parent.has_context::<T>() {
                    return Some(shared);
                }
                search_parent = parent.parent_id;
            }
            None
        })
    }

    pub(crate) fn remove_component_node<M: WriteMutations>(
        &mut self,
        to: Option<&mut M>,
        destroy_component_state: bool,
        scope_id: ScopeId,
        replace_with: Option<usize>,
    ) {
        // If this is a suspense boundary, remove the suspended nodes as well
        SuspenseContext::remove_suspended_nodes::<M>(self, scope_id, destroy_component_state);

        // Remove the component from the dom
        if let Some(node) = self.scopes[scope_id.0].last_rendered_node.clone() {
            node.remove_node_inner(self, to, destroy_component_state, replace_with)
        };

        if destroy_component_state {
            // Now drop all the resources
            self.drop_scope(scope_id);
        }
    }

    pub(crate) fn remove_scope(self: &Rc<Self>, id: ScopeId) {
        {
            let borrow = self.scope_states.borrow();
            if let Some(scope) = &borrow[id.0] {
                // Manually drop tasks, hooks, and contexts inside of the runtime
                self.in_scope(id, || {
                    // Drop all spawned tasks - order doesn't matter since tasks don't rely on eachother
                    // In theory nested tasks might not like this
                    for id in scope.spawned_tasks.take() {
                        self.remove_task(id);
                    }

                    // Drop all queued effects
                    self.pending_effects
                        .borrow_mut()
                        .remove(&ScopeOrder::new(scope.height, scope.id));

                    // Drop all hooks in reverse order in case a hook depends on another hook.
                    for hook in scope.hooks.take().drain(..).rev() {
                        drop(hook);
                    }

                    // Drop all contexts
                    scope.shared_contexts.take();
                });
            }
        }
        self.scope_states.borrow_mut()[id.0].take();
    }

use std::cell::Cell;
use std::rc::Rc;

use dioxus::prelude::*;
use dioxus_core::{Runtime, ScopeId, current_scope_id, try_consume_context};

thread_local! {
  static SHOW: Cell<bool> = const { Cell::new(true) };
}

#[derive(Clone, Debug, PartialEq)]
struct Theme(&'static str);

/// A hook value that reports when it is dropped.
struct Noisy(&'static str);
impl Drop for Noisy {
  fn drop(&mut self) {
    println!("  drop hook {} (current scope {:?})", self.0, current_scope_id());
  }
}

fn here(name: &str) {
  let id = current_scope_id();
  let rt = Runtime::current();
  println!(
    "  run {name}: {:?} height={} parent={:?} Theme={:?}",
    id.0,
    rt.height(id),
    rt.parent_scope(id).map(|p| p.0),
    try_consume_context::<Theme>().map(|t| t.0)
  );
}

fn app() -> Element {
  let show = SHOW.with(|s| s.get());
  rsx! {
    if show {
      Parent {}
    }
  }
}

#[component]
fn Parent() -> Element {
  use_context_provider(|| Theme("dark"));
  use_hook(|| Rc::new(Noisy("Parent#1")));
  use_drop(|| println!("  use_drop Parent: Theme={:?}", try_consume_context::<Theme>().map(|t| t.0)));
  use_hook(|| Rc::new(Noisy("Parent#3")));
  here("Parent");
  rsx! {
    Child {}
    Sibling {}
  }
}

#[component]
fn Child() -> Element {
  use_hook(|| Rc::new(Noisy("Child#0")));
  use_context_provider(|| Theme("light"));
  use_hook(|| Rc::new(Noisy("Child#2")));
  here("Child");
  rsx! { GrandChild {} }
}

#[component]
fn GrandChild() -> Element {
  use_hook(|| Rc::new(Noisy("GrandChild#0")));
  here("GrandChild");
  rsx! { "leaf" }
}

#[component]
fn Sibling() -> Element {
  use_hook(|| Rc::new(Noisy("Sibling#0")));
  here("Sibling");
  rsx! { "sibling" }
}

fn main() {
  let mut dom = VirtualDom::new(app);
  println!("== rebuild");
  dom.rebuild_in_place();

  println!("== hide Parent");
  SHOW.with(|s| s.set(false));
  dom.mark_dirty(ScopeId::APP);
  dom.render_immediate_to_vec();

  println!("== show Parent again");
  SHOW.with(|s| s.set(true));
  dom.mark_dirty(ScopeId::APP);
  dom.render_immediate_to_vec();

  println!("== drop the VirtualDom");
  drop(dom);
}

== rebuild
  run Parent: 4 height=4 parent=Some(3) Theme=Some("dark")
  run Child: 5 height=5 parent=Some(4) Theme=Some("light")
  run GrandChild: 6 height=6 parent=Some(5) Theme=Some("light")
  run Sibling: 7 height=5 parent=Some(4) Theme=Some("dark")
== hide Parent
  drop hook GrandChild#0 (current scope ScopeId(6, "scope_life::GrandChild"))
  drop hook Child#2 (current scope ScopeId(5, "scope_life::Child"))
  drop hook Child#0 (current scope ScopeId(5, "scope_life::Child"))
  drop hook Sibling#0 (current scope ScopeId(7, "scope_life::Sibling"))
  drop hook Parent#3 (current scope ScopeId(4, "scope_life::Parent"))
  use_drop Parent: Theme=Some("dark")
  drop hook Parent#1 (current scope ScopeId(4, "scope_life::Parent"))
...
== drop the VirtualDom
  drop hook GrandChild#0 (current scope ScopeId(5, "scope_life::GrandChild"))
  drop hook Child#2 (current scope ScopeId(7, "scope_life::Child"))
  drop hook Child#0 (current scope ScopeId(7, "scope_life::Child"))
  drop hook Sibling#0 (current scope ScopeId(6, "scope_life::Sibling"))
  drop hook Parent#3 (current scope ScopeId(4, "scope_life::Parent"))
  use_drop Parent: Theme=Some("dark")
  drop hook Parent#1 (current scope ScopeId(4, "scope_life::Parent"))

== show Parent again
  run Parent: 4 height=4 parent=Some(3) Theme=Some("dark")
  run Child: 7 height=5 parent=Some(4) Theme=Some("light")
  run GrandChild: 5 height=6 parent=Some(7) Theme=Some("light")
  run Sibling: 6 height=5 parent=Some(4) Theme=Some("dark")