Fix early drop of eventhandlers (#2126)

* fix early drop of eventhandlers

* add a test for stale props that are memorized in place

* fix clippy

packages/core-macro/src/props/mod.rs

@@ -648,38 +648,45 @@ mod struct_info {
                 )*
             };
 
+            // If there are signals, we automatically try to memoize the signals
             if !signal_fields.is_empty() {
                 Ok(quote! {
-                    // First check if the fields are equal
+                    // First check if the fields are equal. This will compare the signal fields by pointer
                     let exactly_equal = self == new;
                     if exactly_equal {
+                        // If they are return early, they can be memoized without any changes
                         return true;
                     }
 
-                    // If they are not, move over the signal fields and check if they are equal
+                    // If they are not, move the signal fields into self and check if they are equal now that the signal fields are equal
                     #(
                         let mut #signal_fields = self.#signal_fields;
                         self.#signal_fields = new.#signal_fields;
                     )*
 
-                    // Then check if the fields are equal again
+                    // Then check if the fields are equal now that we know the signal fields are equal
+                    // NOTE: we don't compare other fields individually because we want to let users opt-out of memoization for certain fields by implementing PartialEq themselves
                     let non_signal_fields_equal = self == new;
 
-                    // If they are not equal, we still need to rerun the component
+                    // If they are not equal, we need to move over all the fields to self
                     if !non_signal_fields_equal {
-                        return false;
+                        *self = new.clone();
                     }
-
+                    // Move any signal and event fields into their old container.
+                    // We update signals and event handlers in place so that they are always up to date even if they were moved into a future in a previous render
                     #move_signal_fields
                     #move_event_handlers
 
-                    true
+                    non_signal_fields_equal
                 })
             } else {
                 Ok(quote! {
                     let equal = self == new;
-                    if equal {
-                        #move_event_handlers
+                    // Move any signal and event fields into their old container.
+                    #move_event_handlers
+                    // If they are not equal, we need to move over all the fields to self
+                    if !equal {
+                        *self = new.clone();
                     }
                     equal
                 })

packages/core-macro/tests/values_memoize_in_place.rs

@@ -0,0 +1,75 @@
+use dioxus::prelude::*;
+
+thread_local! {
+    static DROP_COUNT: std::cell::RefCell<usize> = const { std::cell::RefCell::new(0) };
+}
+
+#[test]
+fn values_memoize_in_place() {
+    let mut dom = VirtualDom::new(app);
+
+    dom.rebuild_in_place();
+    dom.mark_dirty(ScopeId::ROOT);
+    for _ in 0..20 {
+        dom.render_immediate(&mut dioxus_core::NoOpMutations);
+    }
+    dom.render_immediate(&mut dioxus_core::NoOpMutations);
+    // As we rerun the app, the drop count should be 15 one for each render of the app component
+    let drop_count = DROP_COUNT.with(|c| *c.borrow());
+    assert_eq!(drop_count, 15);
+}
+
+struct CountsDrop;
+
+impl Drop for CountsDrop {
+    fn drop(&mut self) {
+        DROP_COUNT.with(|c| *c.borrow_mut() += 1);
+    }
+}
+
+fn app() -> Element {
+    let mut count = use_signal(|| 0);
+    let x = CountsDrop;
+
+    if generation() < 15 {
+        count += 1;
+    }
+
+    rsx! {
+        TakesEventHandler {
+            click: move |num| {
+                // Force the closure to own the drop counter
+                let _ = &x;
+                println!("num is {num}");
+            },
+            children: count() / 2
+        }
+        TakesSignal { sig: count(), children: count() / 2 }
+    }
+}
+
+#[component]
+fn TakesEventHandler(click: EventHandler<usize>, children: usize) -> Element {
+    let first_render_click = use_hook(move || click);
+    if generation() > 0 {
+        // Make sure the event handler is memoized in place and never gets dropped
+        first_render_click(children);
+    }
+
+    rsx! {
+        button { "{children}" }
+    }
+}
+
+#[component]
+fn TakesSignal(sig: ReadOnlySignal<usize>, children: usize) -> Element {
+    let first_render_sig = use_hook(move || sig);
+    if generation() > 0 {
+        // Make sure the signal is memoized in place and never gets dropped
+        println!("{first_render_sig}");
+    }
+
+    rsx! {
+        button { "{children}" }
+    }
+}