[Shared] Include the type name in FromStatic errors

crates/darksouls3/src/sprj/chr_ins.rs

@@ -1,4 +1,4 @@
-use std::ptr::NonNull;
+use std::{borrow::Cow, ptr::NonNull};
 
 use shared::{
     FromStatic, InstanceError, InstanceResult, OwnedPtr, Subclass, Superclass, UnknownStruct,
@@ -258,11 +258,11 @@ impl PlayerIns {
     pub unsafe fn local_player() -> InstanceResult<&'static mut Self> {
         unsafe {
             let Ok(world_chr_man) = WorldChrMan::instance() else {
-                return Err(InstanceError::NotFound);
+                return Err(InstanceError::NotFound(Cow::Borrowed("PlayerIns")));
             };
 
             let Some(mut player) = world_chr_man.main_player else {
-                return Err(InstanceError::NotFound);
+                return Err(InstanceError::NotFound(Cow::Borrowed("PlayerIns")));
             };
 
             Ok(player.as_mut())

crates/darksouls3/src/sprj/item.rs

@@ -3,7 +3,7 @@ use std::{borrow::Cow, fmt, ops, ptr, sync::LazyLock};
 
 use pelite::pe64::Pe;
 
-use shared::{FromStatic, InstanceError, InstanceResult, Program, util::IncompleteArrayField};
+use shared::{FromStatic, InstanceResult, Program, util::IncompleteArrayField};
 
 use super::ItemId;
 use crate::rva;
@@ -20,11 +20,7 @@ impl FromStatic for MapItemMan {
 
     /// Returns the singleton instance of `MapItemMan`.
     unsafe fn instance() -> InstanceResult<&'static mut Self> {
-        let target = Program::current()
-            .rva_to_va(rva::get().map_item_man_ptr)
-            .map_err(|_| InstanceError::NotFound)? as *const *mut Self;
-
-        unsafe { (*target).as_mut() }.ok_or(InstanceError::Null)
+        unsafe { shared::load_static_indirect(rva::get().map_item_man_ptr) }
     }
 }
 

crates/eldenring/src/cs/chr_ins.rs

@@ -1,8 +1,6 @@
-use bitfield::bitfield;
-use std::fmt::Display;
-use std::mem::transmute;
-use std::ptr::NonNull;
+use std::{borrow::Cow, fmt::Display, mem::transmute, ptr::NonNull};
 
+use bitfield::bitfield;
 use pelite::pe64::Pe;
 use vtable_rs::VPtr;
 
@@ -923,13 +921,13 @@ impl PlayerIns {
     pub unsafe fn local_player() -> InstanceResult<&'static mut Self> {
         unsafe {
             let Ok(world_chr_man) = WorldChrMan::instance() else {
-                return Err(InstanceError::NotFound);
+                return Err(InstanceError::NotFound(Cow::Borrowed("PlayerIns")));
             };
 
             world_chr_man
                 .main_player
                 .as_deref_mut()
-                .ok_or(InstanceError::NotFound)
+                .ok_or(InstanceError::NotFound(Cow::Borrowed("PlayerIns")))
         }
     }
 }

crates/eldenring/src/dlcr.rs

@@ -1,10 +1,10 @@
 use std::{borrow::Cow, ptr::NonNull};
 
-use shared::{FromStatic, OwnedPtr, Program};
+use shared::{FromStatic, OwnedPtr};
 
 use vtable_rs::VPtr;
 
-use crate::{Vector, dlkr::DLAllocatorBase};
+use crate::{Vector, dlkr::DLAllocatorBase, rva};
 
 #[vtable_rs::vtable]
 pub trait DLCipherKeyVmt {
@@ -346,20 +346,6 @@ impl FromStatic for CryptoSPIRegistry {
     }
 
     unsafe fn instance() -> fromsoftware_shared::InstanceResult<&'static mut Self> {
-        use crate::rva;
-        use pelite::pe64::Pe;
-
-        let target = Program::current()
-            .rva_to_va(rva::get().crypto_spi_registry)
-            .map_err(|_| fromsoftware_shared::InstanceError::NotFound)?
-            as *mut Option<NonNull<CryptoSPIRegistry>>;
-
-        unsafe {
-            target
-                .as_mut()
-                .and_then(|opt| opt.as_mut())
-                .map(|nn| nn.as_mut())
-                .ok_or(fromsoftware_shared::InstanceError::Null)
-        }
+        unsafe { shared::load_static_indirect(rva::get().crypto_spi_registry) }
     }
 }

crates/shared/src/static.rs

@@ -12,14 +12,14 @@ pub enum InstanceError {
     /// The object's location wasn't found in the executable. This usually means
     /// something is wrong with the logic of how the object is being loaded in
     /// the first place.
-    #[error("Static object not found")]
-    NotFound,
+    #[error("Static object not found: {0}")]
+    NotFound(Cow<'static, str>),
 
     /// The static object is defined, but it's currently set to null. For many
     /// objects, this is a normal occurrence, and just means that the caller
     /// should wait until it's defined to start using it.
-    #[error("Static object not initialized")]
-    Null,
+    #[error("Static object not initialized: {0}")]
+    Null(Cow<'static, str>),
 }
 
 /// A [Result] whose error type is [InstanceError].
@@ -75,7 +75,7 @@ impl<T: FromSingleton> FromStatic for T {
     unsafe fn instance() -> InstanceResult<&'static mut T> {
         address_of::<T>()
             .map(|mut ptr| unsafe { ptr.as_mut() })
-            .ok_or(InstanceError::NotFound)
+            .ok_or(InstanceError::NotFound(Self::name()))
     }
 }
 
@@ -91,9 +91,9 @@ impl<T: FromSingleton> FromStatic for T {
 pub unsafe fn load_static_direct<T: FromStatic>(rva: Rva) -> InstanceResult<&'static mut T> {
     let target = Program::current()
         .rva_to_va(rva)
-        .map_err(|_| InstanceError::NotFound)? as *mut T;
+        .map_err(|_| InstanceError::NotFound(T::name()))? as *mut T;
 
-    unsafe { target.as_mut().ok_or(InstanceError::Null) }
+    unsafe { target.as_mut().ok_or(InstanceError::Null(T::name())) }
 }
 
 /// Loads a static reference to `T` from an [Rva] that points to a pointer to
@@ -107,13 +107,14 @@ pub unsafe fn load_static_direct<T: FromStatic>(rva: Rva) -> InstanceResult<&'st
 pub unsafe fn load_static_indirect<T: FromStatic>(rva: Rva) -> InstanceResult<&'static mut T> {
     let target = Program::current()
         .rva_to_va(rva)
-        .map_err(|_| InstanceError::NotFound)? as *mut Option<NonNull<T>>;
+        .map_err(|_| InstanceError::NotFound(T::name()))?
+        as *mut Option<NonNull<T>>;
 
     unsafe {
         target
             .as_mut()
             .and_then(|opt| opt.as_mut())
             .map(|nn| nn.as_mut())
-            .ok_or(InstanceError::Null)
+            .ok_or(InstanceError::Null(T::name()))
     }
 }