Binary patching rust hot-reloading, sub-second rebuilds, independent server/client hot-reload (#3797)

Enable runtime rust hot patching. * roll back wry to 0.45 * cleanup rustc * wip * wip: fix client/server * get the subsecond cli thing working again * back to list of builds but with accessors * migrate some methods to workspace, clean up impl a bit * pass mode through build context * use a build context, similar to cargo/rustc * merge BuildUpdate and HandleUpdate into BuilderUpdate * Move more resolution of args into runner * migrate some methods to runner * hoist out fullstack * fix build request resolver * yay request is cleaned up * fixup resolution a bit * spawn off the build! * re-wire android autodetection * re-wire android autodetection * wire back up a few more things * re-wire tooling verification * I think it's mostly in the right condition for regular app * add depinfo parser * yay okay works with regular apps again * full rebuilds are back * rewire file wtcher * wire patch! * yayyyyyy patching works and is really fast * yay android works * clean up stdout piping * yayyy memap on android so we don't need root * create a static wasm jump table * wip: global offset table for wasm * wip... thinking about making the patches relocatable * wip: customized relocation * YESSSSSS RELOCATABLE WASM * clean up impl a bit * lil bit more cleanup * lil bit more * lil bit more cleanup * lil bit more cleanup, support 32 bit platforms * sick, wasm is completely pic * hmmmm not quite working yet * woooo, patches loading from rust+wasm * integrated into the cli 😎 * condense a bit * cleaned up request a bit * bust fingerprints * Make the file diffing logic a bit more sensible * still working through a few issues, server launches but is acting weird * fix merge conflict * more merge issues * remove stuff we don't want anymore * revert name change * wip: server not working anymore :( * split apart "dioxus fullstack" into "dioxus server" and "dioxus web" * fixup a few more compile errors * grrr opening server * simultaneous frontend and backend patching * use rustc wrapper * wip: passing assets to jumptable * migrate project-like examples * patchy patchy server fns! * rollback some random changes * unwind the js files * rollback hash * no need for patch * more cleanups * lil bit more cleanup, remove some old cruft * allow patching when wasm webpage is closed * tiny bit more robust * lil bit of clean up * clean up ws code * bit more clean ups * condense * undo file moves * move back other project * move other project * migrate out harness and janky CLI * fix compile * anonymize some files, heavily document others * lots more documentation, for posterity! * ton more docs * clean up the cli a bit more * more ws cleanup * more cleanup * migrate build id to cli-config * add command file handling * random small cleanups * wip.... * wip.... * fix: use workspace for krate discovery * fix panic logging on serve by placing it *after* the logs * reorder logging to be sensible on success * bring back swc * ws cruft * small patches to relocs in loader * bump krates * hoist main funcs into the ifunc table, fixing wasm * fix tui output for long lines * add more linker logging * wow, incredible, we build fat binaries, holy heckkkkk * fix args for frontend/backend * small cleanups * properly send along build IDs to clients * fix workspace compiles * clean up jump table work a bit * clean up logging a bit * open existing * fixup some commands * open existing browser integration * wire up the new dx serve client/server syntax * fixup `dx run` command * bring back some old functionality * fix serverfn feature sets * remove toast animation and simplify its code a bit * less intrusive toast * dont change build status when patching on web * add proper cache busting to vcomponent * clean up the patch file a bit * more lints/checks cleaned up * go back to TargetArgs but a BuildTargets resolved struct * clean up more nits * use an atomicptr for jumptable * fix interaction with initial web load + suspense * don't run asset system on wasm/bindgen js in dev * reduce blast radius of PR * use profile to determine if we're in release * cleanup prod html template * cleanup profiles * fix feature resolution of fullstack * if fullstack is explicitly false, don't use it * light cleanups * drop carg config2 * pass along linker args properly * make workspace examples compile with dx again * fewer unwraps and better error loggign * bit more error handlign * small cleanup * drive-by cleanups * use queries instead of initialize for aslr stuff * fix hotpatch with higher opt level * fix aslr bug from multiple clients * fix merge conflict * fix typos * clippy * fix miscompile * fix doctest * properly rollback wry to 0.45 * fix markdown path issues, other test issues * fix test in router * fix release mode test * fix some more tests, clean up a few more items * use fnptr instead of typeid * clean up memozation via subsecond in core * use "main" as sentinel * fix imports and re-exports * get off __rust_alloc for aslr offset detection * wip * wip... fixing unoptimized web * hmmmm mmmm * close,ish, still missing the wasmbindgen dynaimc imports * aha! full wasm works now - disable externref when compilng patch modules - manually link wasm instrinsics - displace the __wbindgen_placeholder__ table with the synthesized wbg imports what an awful pain. There might be a few items missing, so will test against the docsite shortly * remove failing test * hmmmm things aren't perfect * from what I can tell, relocatable wasm just doesn't work with wasm-bindgen sad https://github.com/rustwasm/wasm-bindgen/issues/1420 * AI IS LITERALLY THE WORST * preserve wasm snippets across compiles * IT HOTPATCHES THE DOCSITE, WE ARE LIVING IN THE FUTURE * remove the macos cfg-out * fix: need to allocate 1 more page * fix url issue * properly span props * properly fill in extra symbols * light cleanups and good docs * delete cruft, better docs * More cleanups and simplifications * clippy, typos * remove harnesses * wasm-bindgen error logging * clean up deps * remove cruft * proper priv/pub * use ifuncs for all env imports * cruft * use par_iter, better output * implement a cache for the base module * delete custom sections * cache the main native module too * add par iter in a few more places * clippy, map ident * better logging and status bars * wip: some small windows support * wip more windowss * fix weird regression * implement windows jump table * small fixes for windows * better windows support * windows support pt2 * rust lld is not msvc * whole archive the rlibs * ignore windows and sys crates * logging * ohhhhhh, pop out dlls * dedupe * thANK GOD FAT LINKING WORKS ON WINDOWS * hoist caching * implement patch based on cache * fix location for pdb * pass data symbols, correct object * add all symbol for windows * add log * treat none rva as undefined * whoops * handle windows calling convention * dont use relocated arm64 stub windows * not all are text? * WINDOWS FUNCTION PATCHING WORKS but issue with statics? * use our own entry * handle windows imp symbols * add log * jump to the real symbol not the layout * whoops * hotpatching windows works completely holy heck yay * drop linker args crate * disable ssg playwright for now * light cleanups * some cleanups / preps: - bump to serverfn 0.8.2 - fix playwright test - fix clippy * use fix from #4042 * bring in other fix for liveview * hoist some configuration * use __aslr_reference instead of aslr_reference * add better errors to patcherror * fix android * panic if patching fails * clean up tomls * wip: fixing wasm compile for server * fullstack wasm again * fix cfg * fixup feature detection * fix issue with features * fix playwright! * add barebones template test harness * fix compatibility between the two hotreload engines * fix preldue of server * fix check for wasm-opt * small fixes
2025-05-06 23:08:59 -07:00
1 parent 71d85e6dd5
commit d976ca184a
@@ -24,6 +24,7 @@ tracing = { workspace = true }
 warnings = { workspace = true }
 futures-util = { workspace = true, default-features = false, features = ["alloc", "std"] }
 serde = { workspace = true, optional = true, features = ["derive"] }
+subsecond = { workspace = true }

 [dev-dependencies]
 dioxus = { workspace = true }
@@ -65,7 +65,7 @@ use dioxus::prelude::*;

 // First, declare a root component
 fn app() -> Element {
-    rsx!{
+    rsx! {
        div { "hello world" }
    }
 }
@@ -479,3 +479,18 @@ pub fn use_hook_with_cleanup<T: Clone + 'static>(
    use_drop(move || cleanup(_value));
    value
 }
+
+/// Force every component to be dirty and require a re-render. Used by hot-reloading.
+///
+/// This might need to change to a different flag in the event hooks order changes within components.
+/// What we really need is a way to mark components as needing a complete rebuild if they were hit by changes.
+pub fn force_all_dirty() {
+    Runtime::with(|rt| {
+        rt.scope_states.borrow_mut().iter().for_each(|state| {
+            if let Some(scope) = state.as_ref() {
+                scope.needs_update();
+            }
+        });
+    })
+    .expect("Runtime to exist");
+}
@@ -93,17 +93,18 @@ pub use crate::innerlude::{
 pub mod prelude {
    pub use crate::innerlude::{
        consume_context, consume_context_from_scope, current_owner, current_scope_id,
-        fc_to_builder, generation, has_context, needs_update, needs_update_any, parent_scope,
-        provide_context, provide_error_boundary, provide_root_context, queue_effect, remove_future,
-        schedule_update, schedule_update_any, spawn, spawn_forever, spawn_isomorphic, suspend,
-        suspense_context, throw_error, try_consume_context, use_after_render, use_before_render,
-        use_drop, use_hook, use_hook_with_cleanup, with_owner, AnyValue, Attribute, Callback,
-        Component, ComponentFunction, Context, Element, ErrorBoundary, ErrorContext, Event,
-        EventHandler, Fragment, HasAttributes, IntoAttributeValue, IntoDynNode,
-        OptionStringFromMarker, Properties, ReactiveContext, RenderError, Runtime, RuntimeGuard,
-        ScopeId, ScopeState, SuperFrom, SuperInto, SuspendedFuture, SuspenseBoundary,
-        SuspenseBoundaryProps, SuspenseContext, SuspenseExtension, Task, Template,
-        TemplateAttribute, TemplateNode, VNode, VNodeInner, VirtualDom,
+        fc_to_builder, force_all_dirty, generation, has_context, needs_update, needs_update_any,
+        parent_scope, provide_context, provide_error_boundary, provide_root_context, queue_effect,
+        remove_future, schedule_update, schedule_update_any, spawn, spawn_forever,
+        spawn_isomorphic, suspend, suspense_context, throw_error, try_consume_context,
+        use_after_render, use_before_render, use_drop, use_hook, use_hook_with_cleanup, with_owner,
+        AnyValue, Attribute, Callback, Component, ComponentFunction, Context, Element,
+        ErrorBoundary, ErrorContext, Event, EventHandler, Fragment, HasAttributes,
+        IntoAttributeValue, IntoDynNode, OptionStringFromMarker, Properties, ReactiveContext,
+        RenderError, Runtime, RuntimeGuard, ScopeId, ScopeState, SuperFrom, SuperInto,
+        SuspendedFuture, SuspenseBoundary, SuspenseBoundaryProps, SuspenseContext,
+        SuspenseExtension, Task, Template, TemplateAttribute, TemplateNode, VNode, VNodeInner,
+        VirtualDom,
    };
 }

@@ -609,10 +609,8 @@ pub struct VComponent {
    /// The name of this component
    pub name: &'static str,

-    /// The function pointer of the component, known at compile time
-    ///
-    /// It is possible that components get folded at compile time, so these shouldn't be really used as a key
-    pub(crate) render_fn: TypeId,
+    /// The raw pointer to the render function
+    pub(crate) render_fn: usize,

    /// The props for this component
    pub(crate) props: BoxedAnyProps,
@@ -622,8 +620,8 @@ impl Clone for VComponent {
    fn clone(&self) -> Self {
        Self {
            name: self.name,
-            render_fn: self.render_fn,
            props: self.props.duplicate(),
+            render_fn: self.render_fn,
        }
    }
 }
@@ -638,7 +636,7 @@ impl VComponent {
    where
        P: Properties + 'static,
    {
-        let render_fn = component.id();
+        let render_fn = component.fn_ptr();
        let props = Box::new(VProps::new(
            component,
            <P as Properties>::memoize,
@@ -647,9 +645,9 @@ impl VComponent {
        ));

        VComponent {
+            render_fn,
            name: fn_name,
            props,
-            render_fn,
        }
    }

@@ -1,4 +1,4 @@
-use std::{any::TypeId, fmt::Arguments};
+use std::fmt::Arguments;

 use crate::innerlude::*;

@@ -167,27 +167,39 @@ pub fn verify_component_called_as_component<C: ComponentFunction<P, M>, P, M>(co
    )
 )]
 pub trait ComponentFunction<Props, Marker = ()>: Clone + 'static {
-    /// Get the type id of the component.
-    fn id(&self) -> TypeId {
-        TypeId::of::<Self>()
-    }
+    /// Get the raw address of the component render function.
+    fn fn_ptr(&self) -> usize;

    /// Convert the component to a function that takes props and returns an element.
    fn rebuild(&self, props: Props) -> Element;
 }

 /// Accept any callbacks that take props
-impl<F: Fn(P) -> Element + Clone + 'static, P> ComponentFunction<P> for F {
+impl<F, P> ComponentFunction<P> for F
+where
+    F: Fn(P) -> Element + Clone + 'static,
+{
    fn rebuild(&self, props: P) -> Element {
-        self(props)
+        subsecond::HotFn::current(self.clone()).call((props,))
+    }
+
+    fn fn_ptr(&self) -> usize {
+        subsecond::HotFn::current(self.clone()).ptr_address() as usize
    }
 }

 /// Accept any callbacks that take no props
 pub struct EmptyMarker;
-impl<F: Fn() -> Element + Clone + 'static> ComponentFunction<(), EmptyMarker> for F {
-    fn rebuild(&self, _: ()) -> Element {
-        self()
+impl<F> ComponentFunction<(), EmptyMarker> for F
+where
+    F: Fn() -> Element + Clone + 'static,
+{
+    fn rebuild(&self, props: ()) -> Element {
+        subsecond::HotFn::current(self.clone()).call(props)
+    }
+
+    fn fn_ptr(&self) -> usize {
+        subsecond::HotFn::current(self.clone()).ptr_address() as usize
    }
 }

@@ -380,6 +380,9 @@ impl TaskType {
 /// These messages control how the scheduler will process updates to the UI.
 #[derive(Debug)]
 pub(crate) enum SchedulerMsg {
+    /// All components have been marked as dirty, requiring a full render
+    AllDirty,
+
    /// Immediate updates from Components that mark them as dirty
    Immediate(ScopeId),

@@ -16,7 +16,7 @@ use crate::{Task, VComponent};
 use futures_util::StreamExt;
 use slab::Slab;
 use std::collections::BTreeSet;
-use std::{any::Any, rc::Rc};
+use std::{any::Any, rc::Rc, sync::Arc};
 use tracing::instrument;

 /// A virtual node system that progresses user events and diffs UI trees.
@@ -294,7 +294,7 @@ impl VirtualDom {
        root: impl ComponentFunction<P, M>,
        root_props: P,
    ) -> Self {
-        let render_fn = root.id();
+        let render_fn = root.fn_ptr();
        let props = VProps::new(root, |_, _| true, root_props, "Root");
        Self::new_with_component(VComponent {
            name: "root",
@@ -331,6 +331,9 @@ impl VirtualDom {
        );
        dom.new_scope(Box::new(root), "app");

+        #[cfg(debug_assertions)]
+        dom.register_subsecond_handler();
+
        dom
    }

@@ -375,6 +378,19 @@ impl VirtualDom {
        self.base_scope().state().provide_any_context(context);
    }

+    /// Mark all scopes as dirty. Each scope will be re-rendered.
+    pub fn mark_all_dirty(&mut self) {
+        let mut orders = vec![];
+
+        for (_idx, scope) in self.scopes.iter() {
+            orders.push(ScopeOrder::new(scope.state().height(), scope.id()));
+        }
+
+        for order in orders {
+            self.queue_scope(order);
+        }
+    }
+
    /// Manually mark a scope as requiring a re-render
    ///
    /// Whenever the Runtime "works", it will re-render this scope
@@ -458,6 +474,7 @@ impl VirtualDom {
                self.mark_task_dirty(Task::from_id(id));
            }
            SchedulerMsg::EffectQueued => {}
+            SchedulerMsg::AllDirty => self.mark_all_dirty(),
        };
    }

@@ -469,6 +486,7 @@ impl VirtualDom {
                SchedulerMsg::Immediate(id) => self.mark_dirty(id),
                SchedulerMsg::TaskNotified(task) => self.mark_task_dirty(Task::from_id(task)),
                SchedulerMsg::EffectQueued => {}
+                SchedulerMsg::AllDirty => self.mark_all_dirty(),
            }
        }
    }
@@ -744,6 +762,14 @@ impl VirtualDom {
        let event = crate::Event::new(event, bubbling);
        self.runtime().handle_event(name, event, element);
    }
+
+    #[cfg(debug_assertions)]
+    fn register_subsecond_handler(&self) {
+        let sender = self.runtime().sender.clone();
+        subsecond::register_handler(Arc::new(move || {
+            _ = sender.unbounded_send(SchedulerMsg::AllDirty);
+        }));
+    }
 }

 impl Drop for VirtualDom {