generational-box

pub struct GenerationalBox<T, S: 'static = UnsyncStorage> {
    raw: GenerationalPointer<S>,
    _marker: PhantomData<T>,
}

pub(crate) struct GenerationalLocation {
    /// The generation this location is associated with. Using the location after this generation is invalidated will return errors.
    generation: NonZeroU64,
    #[cfg(any(debug_assertions, feature = "debug_ownership"))]
    created_at: &'static std::panic::Location<'static>,
}

##### debug
GenerationalBox<i32>          = 24
GenerationalBox<i32, Sync>    = 24
CopyValue<i32>                = 32
Signal<i32>                   = 32
Signal<Vec<String>>           = 32
Memo<i32>                     = 64
Option<Signal<i32>>           = 32
##### --release
GenerationalBox<i32>          = 16
GenerationalBox<i32, Sync>    = 16
CopyValue<i32>                = 24
Signal<i32>                   = 24
Signal<Vec<String>>           = 24
Memo<i32>                     = 48
Option<Signal<i32>>           = 24

pub struct UnsyncStorage {
    borrow_info: MemoryLocationBorrowInfo,
    data: RefCell<StorageEntry<RefCellStorageEntryData>>,
}

    fn create_new(
        value: RefCellStorageEntryData,
        #[allow(unused)] caller: &'static std::panic::Location<'static>,
    ) -> GenerationalPointer<Self> {
        UNSYNC_RUNTIME.with(|runtime| match runtime.borrow_mut().pop() {
            Some(storage) => {
                let mut write = storage.data.borrow_mut();
                let location = GenerationalLocation {
                    generation: write.generation(),
                    #[cfg(any(debug_assertions, feature = "debug_borrows"))]
                    created_at: caller,
                };
                write.data = value;
                GenerationalPointer { storage, location }
            }
            None => {
                let storage: &'static Self = &*Box::leak(Box::new(Self {
                    borrow_info: Default::default(),
                    data: RefCell::new(StorageEntry::new(value)),
                }));
                // ...
                GenerationalPointer { storage, location }
            }
        })
    }

            let borrow = pointer
                .storage
                .data
                .try_borrow()
                .map_err(|_| pointer.storage.borrow_info.borrow_error())?;
            if !borrow.valid(&pointer.location) {
                return Err(BorrowError::Dropped(ValueDroppedError::new_for_location(
                    pointer.location,
                )));
            }

    fn recycle(pointer: GenerationalPointer<Self>) {
        let mut borrow_mut = pointer.storage.data.borrow_mut();

        // First check if the generation is still valid
        if !borrow_mut.valid(&pointer.location) {
            return;
        }

        borrow_mut.increment_generation();
        // Then decrement the reference count or drop the value if it's the last reference
        match &mut borrow_mut.data {
            // If this is the original reference, drop the value
            RefCellStorageEntryData::Data(_) => borrow_mut.data = RefCellStorageEntryData::Empty,
            // If this is a rc, just ignore the drop
            RefCellStorageEntryData::Rc(_) => {}
            // If this is a reference, decrement the reference count
            RefCellStorageEntryData::Reference(reference) => {
                let reference = *reference;
                drop(borrow_mut);
                drop_ref(reference);
            }
            RefCellStorageEntryData::Empty => {}
        }

        UNSYNC_RUNTIME.with(|runtime| runtime.borrow_mut().push(pointer.storage));
    }

use generational_box::{AnyStorage, GenerationalBox, UnsyncStorage};

fn main() {
  let owner = UnsyncStorage::owner();
  let a: GenerationalBox<String> = owner.insert(String::from("hello"));
  let b = a; // Copy：两个句柄指向同一格
  println!("a.id() = {:?}", a.id());
  println!("b.read() = {}", *b.read());
  *a.write() += " world";
  println!("b.read() = {}", *b.read());

  drop(owner); // Owner 回收它插入过的所有格子
  match a.try_read() {
    Ok(v) => println!("still alive: {}", *v),
    Err(e) => {
      println!("try_read: Err({e:?})");
      println!("Display: {e}");
    }
  }

  // 新的 Owner 再插一个值：拿到的是刚回收的那一格，代数 +1
  let owner2 = UnsyncStorage::owner();
  let c: GenerationalBox<i32> = owner2.insert(42);
  println!("c.id() = {:?}", c.id());
  println!("a.try_read().is_err() = {}", a.try_read().is_err());

  // insert_rc：一个 Reference 格指向一个 Rc 格，占两格
  let d: GenerationalBox<i32> = owner2.insert_rc(7);
  println!("d.id() = {:?}", d.id());
  println!("d.raw_ptr() = {:?}", d.raw_ptr());

  // 最后：read() 一个已回收的句柄
  drop(owner2);
  println!("--- c.read() after owner2 dropped ---");
  let _ = c.read();
}

a.id() = 0x1050e9a58@1
b.read() = hello
b.read() = hello world
try_read: Err(Dropped(ValueDroppedError { created_at: Location { file: "src/bin/gb_basic.rs", line: 5, column: 42 } }))
Display: Failed to borrow because the value was dropped.created_at: src/bin/gb_basic.rs:5:42
...
d.id() = 0x1050ea018@1
d.raw_ptr() = 0x1050ea018
--- c.read() after owner2 dropped ---

thread 'main' (1205136) panicked at src/bin/gb_basic.rs:35:13:
called `Result::unwrap()` on an `Err` value: Dropped(ValueDroppedError { created_at: Location { file: "src/bin/gb_basic.rs", line: 23, column: 40 } })
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

impl Display for ValueDroppedError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("Failed to borrow because the value was dropped.")?;
        #[cfg(any(debug_assertions, feature = "debug_ownership"))]
        f.write_fmt(format_args!("created_at: {}", self.created_at))?;
        Ok(())
    }
}

try_read: Err(Dropped(ValueDroppedError))
Display: Failed to borrow because the value was dropped.
...
called `Result::unwrap()` on an `Err` value: Dropped(ValueDroppedError)

##### debug
[读+写] Failed to borrow mutably because the value was already borrowed immutably.borrowed_at:	src/bin/gb_display.rs:7:17	src/bin/gb_display.rs:8:17
[写+读] Failed to borrow because the value was already borrowed mutably.borrowed_mut_at: src/bin/gb_display.rs:12:16
[写+写] Failed to borrow because the value was already borrowed mutably.borrowed_mut_at: src/bin/gb_display.rs:12:16
##### --release
[读+写] Failed to borrow mutably because the value was already borrowed immutably.
[写+读] Failed to borrow because the value was already borrowed mutably.
[写+写] Failed to borrow mutably because the value was already borrowed immutably.

fn sync_read_while_write() -> Element {
  let mut count = use_signal_sync(|| 0);
  let other = count;
  let _w = count.write();
  println!("got write lock, now reading...");
  let _r = other.read();
  println!("never printed");
  rsx! {}
}

got write lock, now reading...
2 秒后主线程仍然卡在 read() 里，退出

pub struct CopyValue<T, S: 'static = UnsyncStorage> {
    pub(crate) value: GenerationalBox<T, S>,
    pub(crate) origin_scope: ScopeId,
}

#[component]
fn Child(slot: Signal<Option<Signal<i32>>>) -> Element {
  let s = use_signal(|| 7); // 第 6 行：这个 signal 属于 Child
  use_hook(move || slot.set(Some(s)));
  rsx! { "child" }
}

fn app() -> Element {
  let slot = use_signal(|| None::<Signal<i32>>);
  let mut show = use_signal(|| true);
  let read = move |_| {
    let s = slot.peek().unwrap();
    match s.try_read() {
      Ok(v) => println!("[read] Ok({})", *v),
      Err(e) => println!("[read] Err: {e}"),
    }
  };
  rsx! {
    button { onclick: read, "read" }
    button { onclick: move |_| show.set(false), "hide" }
    button { onclick: move |_| println!("[read()] {}", slot.peek().unwrap()()), "read()" }
    if show() { Child { slot } }
  }
}

html: <button>read</button><button>hide</button><button>read()</button>child
--- click read (child alive)
 WARN dioxus_signals::warnings::__copy_value_hoisted: A Copy Value created in ScopeId(4, "gb_dropped::Child") (at src/bin/gb_dropped.rs:6:11). It will be dropped when that scope is dropped, but it was used in ScopeId(3, "root") (at src/bin/gb_dropped.rs:16:13) which is not a descendant of the owning scope.
This may cause reads or writes to fail because the value is dropped while it still held.

Help:
Copy values (like CopyValue, Signal, Memo, and Resource) are owned by the scope they are created in. If you use the value in a scope that may be dropped after the origin scope,
it is very easy to use the value after it has been dropped. To fix this, you can move the value to the parent of all of the scopes that it is used in.
...
[read] Ok(7)
--- click hide
html: <button>read</button><button>hide</button><button>read()</button>
--- click read (child dropped)
 WARN dioxus_signals::warnings::__copy_value_hoisted: A Copy Value created in ScopeId(4) (at src/bin/gb_dropped.rs:6:11). ...
[read] Err: Failed to borrow because the value was dropped.created_at: src/bin/gb_dropped.rs:6:11
--- click read() (child dropped)
 WARN dioxus_signals::warnings::__copy_value_hoisted: A Copy Value created in ScopeId(4) (at src/bin/gb_dropped.rs:6:11). ...

thread 'main' (1204091) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dioxus-signals-0.7.10/src/read.rs:259:38:
called `Result::unwrap()` on an `Err` value: Dropped(ValueDroppedError { created_at: Location { file: "src/bin/gb_dropped.rs", line: 6, column: 11 } })
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

html: <button>read</button><button>hide</button><button>read()</button>child
--- click read (child alive)
[read] Ok(7)
--- click hide
html: <button>read</button><button>hide</button><button>read()</button>
--- click read (child dropped)
[read] Err: Failed to borrow because the value was dropped.
--- click read() (child dropped)

thread 'main' (1204276) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dioxus-signals-0.7.10/src/read.rs:259:38:
called `Result::unwrap()` on an `Err` value: Dropped(ValueDroppedError)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

c.id() = 0x1050e9a58@2
a.try_read().is_err() = true