Use StorageAutoPtr to make VsStoragePtr work

storage/src/storage_auto_ptr.rs

@@ -1,11 +1,22 @@
+use std::fmt::{self, Debug};
 use std::{cell::RefCell, error::Error, rc::Weak};
 
 use crate::{StorageBackend, StorageEntity, StorageEntryPtr, StorageTx};
 
 pub struct StorageAutoPtr<SB: StorageBackend, SE: for<'a> StorageEntity<'a, SB, SB::Tx<'a>>> {
   pub(crate) _marker: std::marker::PhantomData<SE>,
   pub(crate) sb: Weak<RefCell<SB>>, // TODO: Does this need to be weak?
-  pub(crate) ptr: StorageEntryPtr,
+  pub ptr: StorageEntryPtr,
+}
+
+impl<SB: StorageBackend, SE: for<'a> StorageEntity<'a, SB, SB::Tx<'a>>> Debug
+  for StorageAutoPtr<SB, SE>
+{
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.debug_struct("StorageAutoPtr")
+      .field("ptr", &self.ptr)
+      .finish()
+  }
 }
 
 impl<SB: StorageBackend, SE: for<'a> StorageEntity<'a, SB, SB::Tx<'a>>> StorageAutoPtr<SB, SE> {

valuescript_vm/src/val_storage.rs

@@ -12,6 +12,7 @@ use crate::{
   vs_class::VsClass,
   vs_function::VsFunction,
   vs_object::VsObject,
+  vs_storage_ptr::VsStoragePtr,
   vs_value::{ToVal, Val},
   Bytecode, VsSymbol,
 };
@@ -46,7 +47,7 @@ impl Tag {
   }
 }
 
-impl<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>> StorageEntity<'a, SB, Tx> for Val {
+impl<'a, SB: StorageBackend + 'static, Tx: StorageTx<'a, SB>> StorageEntity<'a, SB, Tx> for Val {
   fn from_storage_entry(tx: &mut Tx, entry: StorageEntry) -> Result<Self, StorageError<SB>> {
     let mut reader = StorageEntryReader::new(&entry);
     let res = read_from_entry(tx, &mut reader);
@@ -155,7 +156,7 @@ impl<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>> StorageEntity<'a, SB, Tx> fo
   }
 }
 
-fn write_to_entry<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>>(
+fn write_to_entry<'a, SB: StorageBackend + 'static, Tx: StorageTx<'a, SB>>(
   val: &Val,
   tx: &mut Tx,
   writer: &mut StorageEntryWriter,
@@ -238,14 +239,14 @@ fn write_to_entry<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>>(
     }
     Val::StoragePtr(ptr) => {
       writer.write_u8(Tag::StoragePtr.to_byte());
-      writer.entry.refs.push(ptr.ptr);
+      writer.entry.refs.push(ptr.resolver.ptr());
     }
   };
 
   Ok(())
 }
 
-fn write_ptr_to_entry<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>>(
+fn write_ptr_to_entry<'a, SB: StorageBackend + 'static, Tx: StorageTx<'a, SB>>(
   tx: &mut Tx,
   writer: &mut StorageEntryWriter,
   key: RcKey,
@@ -263,7 +264,7 @@ fn write_ptr_to_entry<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>>(
   Ok(())
 }
 
-fn read_from_entry<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>>(
+fn read_from_entry<'a, SB: StorageBackend + 'static, Tx: StorageTx<'a, SB>>(
   tx: &mut Tx,
   reader: &mut StorageEntryReader,
 ) -> Result<Val, StorageError<SB>> {
@@ -389,7 +390,7 @@ fn read_from_entry<'a, SB: StorageBackend, Tx: StorageTx<'a, SB>>(
     Tag::Static => todo!(),
     Tag::Dynamic => todo!(),
     Tag::CopyCounter => todo!(),
-    Tag::StoragePtr => reader.read_ref()?.to_val(),
+    Tag::StoragePtr => VsStoragePtr::new(tx.get_auto_ptr(reader.read_ref()?)).to_val(),
   })
 }
 

valuescript_vm/src/vs_storage_ptr.rs

@@ -1,19 +1,50 @@
-use std::{cell::RefCell, fmt::Debug, rc::Rc};
+use std::{
+  cell::RefCell,
+  fmt::{self, Debug},
+  rc::Rc,
+};
 
-use storage::StorageEntryPtr;
+use storage::{StorageAutoPtr, StorageBackend, StorageEntryPtr};
 
 use crate::vs_value::{ToVal, Val};
 
+pub trait ValResolver: Debug {
+  fn resolve(&self) -> Val;
+  fn ptr(&self) -> StorageEntryPtr;
+}
+
+pub struct StorageValAutoPtr<SB: StorageBackend + 'static> {
+  ptr: StorageAutoPtr<SB, Val>,
+}
+
+impl<SB: StorageBackend> ValResolver for StorageValAutoPtr<SB> {
+  fn resolve(&self) -> Val {
+    self.ptr.resolve().unwrap().unwrap()
+  }
+
+  fn ptr(&self) -> StorageEntryPtr {
+    self.ptr.ptr
+  }
+}
+
+impl<SB: StorageBackend> Debug for StorageValAutoPtr<SB> {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.debug_struct("StorageValAutoPtr")
+      .field("ptr", &self.ptr)
+      .finish()
+  }
+}
+
 #[derive(Debug)]
 pub struct VsStoragePtr {
-  pub ptr: StorageEntryPtr,
+  pub(crate) resolver: Box<dyn ValResolver>,
   cache: RefCell<Option<Val>>,
 }
 
 impl VsStoragePtr {
-  pub fn from_ptr(ptr: StorageEntryPtr) -> Self {
+  pub fn new<SB: StorageBackend + 'static>(auto_ptr: StorageAutoPtr<SB, Val>) -> Self {
     Self {
-      ptr,
+      resolver: Box::new(StorageValAutoPtr { ptr: auto_ptr }),
       cache: RefCell::new(None),
     }
   }
@@ -38,9 +69,3 @@ impl ToVal for VsStoragePtr {
     Val::StoragePtr(Rc::new(self))
   }
 }
-
-impl ToVal for StorageEntryPtr {
-  fn to_val(self) -> Val {
-    VsStoragePtr::from_ptr(self).to_val()
-  }
-}