Remove generics from SupportedParameterType and SupportedReturnType traits (#475)

jprendes · web-flow · commit ae139b02117f · 2025-05-08T20:31:41.000+01:00
Signed-off-by: Jorge Prendes &lt;jorge.prendes@gmail.com&gt;
diff --git a/src/hyperlight_host/src/func/host_functions.rs b/src/hyperlight_host/src/func/host_functions.rs
@@ -87,8 +87,8 @@ macro_rules! impl_host_function {
             impl<R $(, $P)*, F> HostFunction<R, ($($P,)*)> for Arc<Mutex<F>>
             where
                 F: FnMut($($P),*) -> Result<R> + Send + 'static,
-                $($P: SupportedParameterType<$P> + Clone,)*
-                R: SupportedReturnType<R>,
+                $($P: SupportedParameterType + Clone,)*
+                R: SupportedReturnType,
             {
                 /// Register the host function with the given name in the sandbox.
                 #[instrument(
@@ -162,8 +162,8 @@ macro_rules! impl_host_function {
             ) -> Result<()>
             where
                 T: FnMut($($P),*) -> Result<R> + Send + 'static,
-                $($P: SupportedParameterType<$P> + Clone,)*
-                R: SupportedReturnType<R>,
+                $($P: SupportedParameterType + Clone,)*
+                R: SupportedReturnType,
             {
                 const N: usize = impl_host_function!(@count $($P),*);
                 let cloned = self_.clone();
diff --git a/src/hyperlight_host/src/func/param_type.rs b/src/hyperlight_host/src/func/param_type.rs
@@ -24,20 +24,20 @@ use crate::{log_then_return, Result};
 /// valid Hyperlight parameter type.
 ///
 /// For each parameter type Hyperlight supports in host functions, we
-/// provide an implementation for `SupportedParameterType<SupportedType>`
-pub trait SupportedParameterType<T> {
+/// provide an implementation for `SupportedParameterType`
+pub trait SupportedParameterType: Sized {
     /// Get the underlying Hyperlight parameter type representing this
     /// `SupportedParameterType`
     fn get_hyperlight_type() -> ParameterType;
     /// Get the underling Hyperlight parameter value representing this
     /// `SupportedParameterType`
     fn get_hyperlight_value(&self) -> ParameterValue;
     /// Get the actual inner value of this `SupportedParameterType`
-    fn get_inner(a: ParameterValue) -> Result<T>;
+    fn get_inner(a: ParameterValue) -> Result<Self>;
 }
 
 // We can then implement these traits for each type that Hyperlight supports as a parameter or return type
-impl SupportedParameterType<String> for String {
+impl SupportedParameterType for String {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ParameterType {
         ParameterType::String
@@ -59,7 +59,7 @@ impl SupportedParameterType<String> for String {
     }
 }
 
-impl SupportedParameterType<i32> for i32 {
+impl SupportedParameterType for i32 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ParameterType {
         ParameterType::Int
@@ -81,7 +81,7 @@ impl SupportedParameterType<i32> for i32 {
     }
 }
 
-impl SupportedParameterType<u32> for u32 {
+impl SupportedParameterType for u32 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ParameterType {
         ParameterType::UInt
@@ -103,7 +103,7 @@ impl SupportedParameterType<u32> for u32 {
     }
 }
 
-impl SupportedParameterType<i64> for i64 {
+impl SupportedParameterType for i64 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ParameterType {
         ParameterType::Long
@@ -125,7 +125,7 @@ impl SupportedParameterType<i64> for i64 {
     }
 }
 
-impl SupportedParameterType<u64> for u64 {
+impl SupportedParameterType for u64 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ParameterType {
         ParameterType::ULong
@@ -147,7 +147,7 @@ impl SupportedParameterType<u64> for u64 {
     }
 }
 
-impl SupportedParameterType<bool> for bool {
+impl SupportedParameterType for bool {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ParameterType {
         ParameterType::Bool
@@ -169,7 +169,7 @@ impl SupportedParameterType<bool> for bool {
     }
 }
 
-impl SupportedParameterType<Vec<u8>> for Vec<u8> {
+impl SupportedParameterType for Vec<u8> {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ParameterType {
         ParameterType::VecBytes
diff --git a/src/hyperlight_host/src/func/ret_type.rs b/src/hyperlight_host/src/func/ret_type.rs
@@ -21,18 +21,18 @@ use crate::HyperlightError::ReturnValueConversionFailure;
 use crate::{log_then_return, Result};
 
 /// This is a marker trait that is used to indicate that a type is a valid Hyperlight return type.
-pub trait SupportedReturnType<T> {
+pub trait SupportedReturnType: Sized {
     /// Gets the return type of the supported return value
     fn get_hyperlight_type() -> ReturnType;
 
     /// Gets the value of the supported return value
     fn get_hyperlight_value(&self) -> ReturnValue;
 
     /// Gets the inner value of the supported return type
-    fn get_inner(a: ReturnValue) -> Result<T>;
+    fn get_inner(a: ReturnValue) -> Result<Self>;
 }
 
-impl SupportedReturnType<()> for () {
+impl SupportedReturnType for () {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::Void
@@ -54,7 +54,7 @@ impl SupportedReturnType<()> for () {
     }
 }
 
-impl SupportedReturnType<String> for String {
+impl SupportedReturnType for String {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::String
@@ -76,7 +76,7 @@ impl SupportedReturnType<String> for String {
     }
 }
 
-impl SupportedReturnType<i32> for i32 {
+impl SupportedReturnType for i32 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::Int
@@ -98,7 +98,7 @@ impl SupportedReturnType<i32> for i32 {
     }
 }
 
-impl SupportedReturnType<u32> for u32 {
+impl SupportedReturnType for u32 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::UInt
@@ -120,7 +120,7 @@ impl SupportedReturnType<u32> for u32 {
     }
 }
 
-impl SupportedReturnType<i64> for i64 {
+impl SupportedReturnType for i64 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::Long
@@ -142,7 +142,7 @@ impl SupportedReturnType<i64> for i64 {
     }
 }
 
-impl SupportedReturnType<u64> for u64 {
+impl SupportedReturnType for u64 {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::ULong
@@ -164,7 +164,7 @@ impl SupportedReturnType<u64> for u64 {
     }
 }
 
-impl SupportedReturnType<bool> for bool {
+impl SupportedReturnType for bool {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::Bool
@@ -186,7 +186,7 @@ impl SupportedReturnType<bool> for bool {
     }
 }
 
-impl SupportedReturnType<Vec<u8>> for Vec<u8> {
+impl SupportedReturnType for Vec<u8> {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_hyperlight_type() -> ReturnType {
         ReturnType::VecBytes

Original file line number	Diff line number	Diff line change
`@@ -24,20 +24,20 @@ use crate::{log_then_return, Result};`
`24`	`24`	`/// valid Hyperlight parameter type.`
`25`	`25`	`///`
`26`	`26`	`/// For each parameter type Hyperlight supports in host functions, we`
`27`		-/// provide an implementation for `SupportedParameterType<SupportedType>`
`28`		`-pub trait SupportedParameterType<T> {`
	`27`	+/// provide an implementation for `SupportedParameterType`
	`28`	`+pub trait SupportedParameterType: Sized {`
`29`	`29`	`/// Get the underlying Hyperlight parameter type representing this`
`30`	`30`	/// `SupportedParameterType`
`31`	`31`	`fn get_hyperlight_type() -> ParameterType;`
`32`	`32`	`/// Get the underling Hyperlight parameter value representing this`
`33`	`33`	/// `SupportedParameterType`
`34`	`34`	`fn get_hyperlight_value(&self) -> ParameterValue;`
`35`	`35`	/// Get the actual inner value of this `SupportedParameterType`
`36`		`- fn get_inner(a: ParameterValue) -> Result<T>;`
	`36`	`+ fn get_inner(a: ParameterValue) -> Result<Self>;`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`// We can then implement these traits for each type that Hyperlight supports as a parameter or return type`
`40`		`-impl SupportedParameterType<String> for String {`
	`40`	`+impl SupportedParameterType for String {`
`41`	`41`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`42`	`42`	`fn get_hyperlight_type() -> ParameterType {`
`43`	`43`	`ParameterType::String`
`@@ -59,7 +59,7 @@ impl SupportedParameterType<String> for String {`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`-impl SupportedParameterType<i32> for i32 {`
	`62`	`+impl SupportedParameterType for i32 {`
`63`	`63`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`64`	`64`	`fn get_hyperlight_type() -> ParameterType {`
`65`	`65`	`ParameterType::Int`
`@@ -81,7 +81,7 @@ impl SupportedParameterType<i32> for i32 {`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`-impl SupportedParameterType<u32> for u32 {`
	`84`	`+impl SupportedParameterType for u32 {`
`85`	`85`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`86`	`86`	`fn get_hyperlight_type() -> ParameterType {`
`87`	`87`	`ParameterType::UInt`
`@@ -103,7 +103,7 @@ impl SupportedParameterType<u32> for u32 {`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`		`-impl SupportedParameterType<i64> for i64 {`
	`106`	`+impl SupportedParameterType for i64 {`
`107`	`107`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`108`	`108`	`fn get_hyperlight_type() -> ParameterType {`
`109`	`109`	`ParameterType::Long`
`@@ -125,7 +125,7 @@ impl SupportedParameterType<i64> for i64 {`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`		`-impl SupportedParameterType<u64> for u64 {`
	`128`	`+impl SupportedParameterType for u64 {`
`129`	`129`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`130`	`130`	`fn get_hyperlight_type() -> ParameterType {`
`131`	`131`	`ParameterType::ULong`
`@@ -147,7 +147,7 @@ impl SupportedParameterType<u64> for u64 {`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`150`		`-impl SupportedParameterType<bool> for bool {`
	`150`	`+impl SupportedParameterType for bool {`
`151`	`151`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`152`	`152`	`fn get_hyperlight_type() -> ParameterType {`
`153`	`153`	`ParameterType::Bool`
`@@ -169,7 +169,7 @@ impl SupportedParameterType<bool> for bool {`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`
`172`		`-impl SupportedParameterType<Vec<u8>> for Vec<u8> {`
	`172`	`+impl SupportedParameterType for Vec<u8> {`
`173`	`173`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`174`	`174`	`fn get_hyperlight_type() -> ParameterType {`
`175`	`175`	`ParameterType::VecBytes`
Original file line number	Diff line number	Diff line change
`@@ -21,18 +21,18 @@ use crate::HyperlightError::ReturnValueConversionFailure;`
`21`	`21`	`use crate::{log_then_return, Result};`
`22`	`22`
`23`	`23`	`/// This is a marker trait that is used to indicate that a type is a valid Hyperlight return type.`
`24`		`-pub trait SupportedReturnType<T> {`
	`24`	`+pub trait SupportedReturnType: Sized {`
`25`	`25`	`/// Gets the return type of the supported return value`
`26`	`26`	`fn get_hyperlight_type() -> ReturnType;`
`27`	`27`
`28`	`28`	`/// Gets the value of the supported return value`
`29`	`29`	`fn get_hyperlight_value(&self) -> ReturnValue;`
`30`	`30`
`31`	`31`	`/// Gets the inner value of the supported return type`
`32`		`- fn get_inner(a: ReturnValue) -> Result<T>;`
	`32`	`+ fn get_inner(a: ReturnValue) -> Result<Self>;`
`33`	`33`	`}`
`34`	`34`
`35`		`-impl SupportedReturnType<()> for () {`
	`35`	`+impl SupportedReturnType for () {`
`36`	`36`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`37`	`37`	`fn get_hyperlight_type() -> ReturnType {`
`38`	`38`	`ReturnType::Void`
`@@ -54,7 +54,7 @@ impl SupportedReturnType<()> for () {`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`57`		`-impl SupportedReturnType<String> for String {`
	`57`	`+impl SupportedReturnType for String {`
`58`	`58`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`59`	`59`	`fn get_hyperlight_type() -> ReturnType {`
`60`	`60`	`ReturnType::String`
`@@ -76,7 +76,7 @@ impl SupportedReturnType<String> for String {`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`		`-impl SupportedReturnType<i32> for i32 {`
	`79`	`+impl SupportedReturnType for i32 {`
`80`	`80`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`81`	`81`	`fn get_hyperlight_type() -> ReturnType {`
`82`	`82`	`ReturnType::Int`
`@@ -98,7 +98,7 @@ impl SupportedReturnType<i32> for i32 {`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`101`		`-impl SupportedReturnType<u32> for u32 {`
	`101`	`+impl SupportedReturnType for u32 {`
`102`	`102`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`103`	`103`	`fn get_hyperlight_type() -> ReturnType {`
`104`	`104`	`ReturnType::UInt`
`@@ -120,7 +120,7 @@ impl SupportedReturnType<u32> for u32 {`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
`123`		`-impl SupportedReturnType<i64> for i64 {`
	`123`	`+impl SupportedReturnType for i64 {`
`124`	`124`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`125`	`125`	`fn get_hyperlight_type() -> ReturnType {`
`126`	`126`	`ReturnType::Long`
`@@ -142,7 +142,7 @@ impl SupportedReturnType<i64> for i64 {`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`		`-impl SupportedReturnType<u64> for u64 {`
	`145`	`+impl SupportedReturnType for u64 {`
`146`	`146`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`147`	`147`	`fn get_hyperlight_type() -> ReturnType {`
`148`	`148`	`ReturnType::ULong`
`@@ -164,7 +164,7 @@ impl SupportedReturnType<u64> for u64 {`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`
`167`		`-impl SupportedReturnType<bool> for bool {`
	`167`	`+impl SupportedReturnType for bool {`
`168`	`168`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`169`	`169`	`fn get_hyperlight_type() -> ReturnType {`
`170`	`170`	`ReturnType::Bool`
`@@ -186,7 +186,7 @@ impl SupportedReturnType<bool> for bool {`
`186`	`186`	`}`
`187`	`187`	`}`
`188`	`188`
`189`		`-impl SupportedReturnType<Vec<u8>> for Vec<u8> {`
	`189`	`+impl SupportedReturnType for Vec<u8> {`
`190`	`190`	`#[instrument(skip_all, parent = Span::current(), level= "Trace")]`
`191`	`191`	`fn get_hyperlight_type() -> ReturnType {`
`192`	`192`	`ReturnType::VecBytes`