- Use Weak<Effect> instead of Rc<Effect> to support effect release

- Optimize effect test cases to verify correct effect release

Author: fxdmhtt

cache/src/memo.rs

@@ -16,9 +16,7 @@ where
 {
     fn invalidate(&'static self) {
         remove_from_cache(self);
-        self.dependents
-            .iter()
-            .for_each(|dependent| dependent.invalidate());
+        self.dependents.iter().for_each(|d| d.invalidate());
     }
 }
 

cache/src/signal.rs

@@ -1,6 +1,6 @@
 use std::{
     cell::{Ref, RefCell},
-    rc::Rc,
+    rc::{Rc, Weak},
 };
 
 use mvvm::System::ComponentModel::ObservableProperty;
@@ -13,22 +13,26 @@ where
 {
     prop: ObservableProperty<'static, T>,
     dependents: RefCell<Vec<&'static dyn Observable>>,
-    effects: RefCell<Vec<Rc<Effect>>>,
+    effects: RefCell<Vec<Weak<Effect>>>,
 }
 
 impl<T> Signal<T>
 where
     T: Eq + Default + 'static,
 {
     fn invalidate(&self) {
-        self.dependents
-            .borrow()
-            .iter()
-            .for_each(|dependent| dependent.invalidate());
+        self.dependents.borrow().iter().for_each(|d| d.invalidate());
     }
 
     fn flush_effects(&self) {
-        self.effects.borrow().iter().for_each(|effect| effect.run());
+        self.effects.borrow_mut().retain(|w| {
+            if let Some(e) = w.upgrade() {
+                e.run();
+                true
+            } else {
+                false
+            }
+        });
     }
 
     pub fn new(value: Option<T>) -> Rc<Self> {
@@ -65,10 +69,14 @@ where
         {
             self.dependents.borrow_mut().push(*last);
         }
-        if let Some(effect) = call_stack::current_effect_peak()
-            && !self.effects.borrow().iter().any(|e| Rc::ptr_eq(e, &effect))
+        if let Some(e) = call_stack::current_effect_peak()
+            && !self
+                .effects
+                .borrow()
+                .iter()
+                .any(|w| w.as_ptr() == Rc::as_ptr(&e))
         {
-            self.effects.borrow_mut().push(effect);
+            self.effects.borrow_mut().push(Rc::downgrade(&e));
         }
 
         self.prop.GetValue()

macros/tests/effect.rs

@@ -1,5 +1,7 @@
 #![allow(static_mut_refs)]
 
+use std::rc::Rc;
+
 use macros::{effect, memo, signal};
 
 static mut SOURCE_A_CALLED: i32 = 0;
@@ -65,6 +67,26 @@ pub fn effect_f() {
 fn simple_effect_test() {
     A_set(0);
     effect!(effect_e);
+    effect!(|| { effect_f() });
+
+    unsafe { SOURCE_A_CALLED = 0 };
+    unsafe { SOURCE_B_CALLED = 0 };
+    unsafe { DERIVED_C_CALLED = 0 };
+    unsafe { DERIVED_D_CALLED = 0 };
+    unsafe { EFFECT_E_CALLED = 0 };
+    unsafe { EFFECT_F_CALLED = 0 };
+
+    A_set(10);
+
+    assert_eq!(unsafe { SOURCE_A_CALLED }, 0);
+    assert_eq!(unsafe { SOURCE_B_CALLED }, 0);
+    assert_eq!(unsafe { DERIVED_C_CALLED }, 0);
+    assert_eq!(unsafe { DERIVED_D_CALLED }, 0);
+    assert_eq!(unsafe { EFFECT_E_CALLED }, 0);
+    assert_eq!(unsafe { EFFECT_F_CALLED }, 0);
+
+    A_set(0);
+    let _ = Rc::into_raw(effect!(effect_e));
 
     unsafe { SOURCE_A_CALLED = 0 };
     unsafe { SOURCE_B_CALLED = 0 };
@@ -83,7 +105,7 @@ fn simple_effect_test() {
     assert_eq!(unsafe { EFFECT_F_CALLED }, 0);
 
     A_set(0);
-    effect!(|| { effect_f() });
+    let _ = Rc::into_raw(effect!(|| { effect_f() }));
 
     unsafe { SOURCE_A_CALLED = 0 };
     unsafe { SOURCE_B_CALLED = 0 };