Add debug impl to ManagedFunction

Author: OpenByteDev

src/hostfxr/managed_function.rs

@@ -1,8 +1,17 @@
-use std::ops::Deref;
+use std::{ops::Deref, fmt::Debug};
 
 /// A wrapper around a managed function pointer.
 pub struct ManagedFunction<F: ManagedFunctionPtr>(pub(crate) F);
 
+impl <F: ManagedFunctionPtr> Debug for ManagedFunction<F> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ManagedFunction")
+            .field("ptr", &self.0.as_ptr())
+            .field("sig", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F: ManagedFunctionPtr> Deref for ManagedFunction<F> {
     type Target = F;
 

tests/errors.rs

@@ -26,15 +26,15 @@ rusty_fork_test! {
         );
         assert!(invalid_method_name.is_err());
         assert_eq!(
-            unsafe { invalid_method_name.unwrap_err_unchecked() },
+            invalid_method_name.unwrap_err(),
             GetManagedFunctionError::MissingMethod
         );
 
         let invalid_method_signature = fn_loader
             .get_function_with_default_signature(pdcstr!("Test.Program, Test"), pdcstr!("Main"));
         assert!(invalid_method_signature.is_err());
         assert_eq!(
-            unsafe { invalid_method_signature.unwrap_err_unchecked() },
+            invalid_method_signature.unwrap_err(),
             GetManagedFunctionError::MissingMethod
         );
 
@@ -44,8 +44,8 @@ rusty_fork_test! {
         );
         assert!(invalid_type_name.is_err());
         assert_eq!(
-            unsafe { invalid_type_name.unwrap_err_unchecked() },
-            GetManagedFunctionError::TypeNotFound
+            invalid_type_name.unwrap_err(),
+            GetManagedFunctionError::MissingMethod
         );
 
         let invalid_namespace_name = fn_loader.get_function_with_default_signature(
@@ -54,8 +54,8 @@ rusty_fork_test! {
         );
         assert!(invalid_namespace_name.is_err());
         assert_eq!(
-            unsafe { invalid_namespace_name.unwrap_err_unchecked() },
-            GetManagedFunctionError::TypeNotFound
+            invalid_namespace_name.unwrap_err(),
+            GetManagedFunctionError::MissingMethod
         );
 
         let invalid_assembly_name = fn_loader.get_function_with_default_signature(
@@ -64,7 +64,7 @@ rusty_fork_test! {
         );
         assert!(invalid_assembly_name.is_err());
         assert_eq!(
-            unsafe { invalid_assembly_name.unwrap_err_unchecked() },
+            invalid_assembly_name.unwrap_err(),
             GetManagedFunctionError::AssemblyNotFound
         );
 
@@ -74,7 +74,7 @@ rusty_fork_test! {
         );
         assert!(method_not_marked.is_err());
         assert_eq!(
-            unsafe { method_not_marked.unwrap_err_unchecked() },
+            method_not_marked.unwrap_err(),
             GetManagedFunctionError::MethodNotUnmanagedCallersOnly
         );
 
@@ -85,7 +85,7 @@ rusty_fork_test! {
         );
         assert!(invalid_delegate_type_name.is_err());
         assert_eq!(
-            unsafe { invalid_delegate_type_name.unwrap_err_unchecked() },
+            invalid_delegate_type_name.unwrap_err(),
             GetManagedFunctionError::TypeNotFound
         );
 
@@ -109,7 +109,7 @@ rusty_fork_test! {
             .get_function_with_default_signature(pdcstr!("Test.Program, Test"), pdcstr!("Hello"));
         assert!(invalid_assembly_path.is_err());
         assert_eq!(
-            unsafe { invalid_assembly_path.unwrap_err_unchecked() },
+            invalid_assembly_path.unwrap_err(),
             GetManagedFunctionError::AssemblyNotFound
         );
 
@@ -120,7 +120,7 @@ rusty_fork_test! {
             .get_function_with_default_signature(pdcstr!("Test.Program, Test"), pdcstr!("Hello"));
         assert!(non_existant_assembly_path.is_err());
         assert_eq!(
-            unsafe { non_existant_assembly_path.unwrap_err_unchecked() },
+            non_existant_assembly_path.unwrap_err(),
             GetManagedFunctionError::AssemblyNotFound
         );