Move result unwrap used in host_function macro from hl-common to hl-guest-bin

Signed-off-by: Jorge Prendes <jorge.prendes@gmail.com>

Author: jprendes

src/hyperlight_common/src/func/ret_type.rs

@@ -32,6 +32,8 @@ pub trait SupportedReturnType: Sized + Clone + Send + Sync + 'static {
     fn from_value(value: ReturnValue) -> Result<Self, Error>;
 }
 
+#[macro_export]
+#[doc(hidden)]
 macro_rules! for_each_return_type {
     ($macro:ident) => {
         $macro!((), Void);
@@ -76,9 +78,6 @@ pub trait ResultType<E: core::fmt::Debug> {
 
     /// Convert the return type into a `Result<impl SupportedReturnType>`
     fn into_result(self) -> Result<Self::ReturnType, E>;
-
-    /// Convert a result into this type, panicking if needed
-    fn from_result(res: Result<Self::ReturnType, E>) -> Self;
 }
 
 impl<T, E> ResultType<E> for T
@@ -91,11 +90,6 @@ where
     fn into_result(self) -> Result<Self::ReturnType, E> {
         Ok(self)
     }
-
-    fn from_result(res: Result<Self::ReturnType, E>) -> Self {
-        #![allow(clippy::unwrap_used)]
-        res.unwrap()
-    }
 }
 
 impl<T, E> ResultType<E> for Result<T, E>
@@ -108,10 +102,6 @@ where
     fn into_result(self) -> Result<Self::ReturnType, E> {
         self
     }
-
-    fn from_result(res: Result<Self::ReturnType, E>) -> Self {
-        res
-    }
 }
 
 for_each_return_type!(impl_supported_return_type);

src/hyperlight_guest_bin/src/lib.rs

@@ -260,6 +260,36 @@ pub mod __private {
 
     #[linkme::distributed_slice]
     pub static GUEST_FUNCTION_INIT: [fn()];
+
+    pub trait FromResult {
+        type Output;
+        fn from_result(res: Result<Self::Output, HyperlightGuestError>) -> Self;
+    }
+
+    use alloc::string::String;
+    use alloc::vec::Vec;
+
+    use hyperlight_common::for_each_return_type;
+
+    macro_rules! impl_maybe_unwrap {
+        ($ty:ty, $enum:ident) => {
+            impl FromResult for $ty {
+                type Output = Self;
+                fn from_result(res: Result<Self::Output, HyperlightGuestError>) -> Self {
+                    res.unwrap()
+                }
+            }
+
+            impl FromResult for Result<$ty, HyperlightGuestError> {
+                type Output = $ty;
+                fn from_result(res: Result<Self::Output, HyperlightGuestError>) -> Self {
+                    res
+                }
+            }
+        };
+    }
+
+    for_each_return_type!(impl_maybe_unwrap);
 }
 
 #[cfg(feature = "macros")]

src/hyperlight_guest_macro/src/lib.rs

@@ -85,7 +85,7 @@ pub fn guest_function(attr: TokenStream, item: TokenStream) -> TokenStream {
             #[#crate_name::__private::linkme::distributed_slice(#crate_name::__private::GUEST_FUNCTION_INIT)]
             #[linkme(crate = #crate_name::__private::linkme)]
             static REGISTRATION: fn() = || {
-                hyperlight_guest_bin::guest_function::register::register_fn(#exported_name, #ident);
+                #crate_name::guest_function::register::register_fn(#exported_name, #ident);
             };
         };
     };
@@ -194,9 +194,9 @@ pub fn host_function(attr: TokenStream, item: TokenStream) -> TokenStream {
 
     let output = quote! {
         #(#attrs)* #vis #sig {
-            use #crate_name::__private::{ResultType, HyperlightGuestError};
+            use #crate_name::__private::FromResult;
             use #crate_name::host_comm::call_host;
-            <#ret as ResultType<HyperlightGuestError>>::from_result(call_host(#exported_name, (#(#args,)*)))
+            <#ret as FromResult>::from_result(call_host(#exported_name, (#(#args,)*)))
         }
     };