[guest/guest-handle/host-comm] change name of call_host_without_returning function

Signed-off-by: danbugs <[email protected]>

Author: danbugs

README.md

@@ -89,7 +89,7 @@ use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result_from_int
 use hyperlight_guest::error::{HyperlightGuestError, Result};
 use hyperlight_guest_bin::guest_function::definition::GuestFunctionDefinition;
 use hyperlight_guest_bin::guest_function::register::register_function;
-use hyperlight_guest_bin::host_comm::{call_host_function, call_host_function_without_returning};
+use hyperlight_guest_bin::host_comm::{call_host_function, call_host_function_without_returning_result};
 
 fn print_output(function_call: &FunctionCall) -> Result<Vec<u8>> {
     if let ParameterValue::String(message) = function_call.parameters.clone().unwrap()[0].clone() {

src/hyperlight_guest/src/guest_handle/host_comm.rs

@@ -58,7 +58,7 @@ impl GuestHandle {
     ///
     /// Note: The function return value must be obtained by calling
     /// `get_host_return_value`.
-    pub fn call_host_function_without_returning(
+    pub fn call_host_function_without_returning_result(
         &self,
         function_name: &str,
         parameters: Option<Vec<ParameterValue>>,
@@ -95,7 +95,7 @@ impl GuestHandle {
         parameters: Option<Vec<ParameterValue>>,
         return_type: ReturnType,
     ) -> Result<T> {
-        self.call_host_function_without_returning(function_name, parameters, return_type)?;
+        self.call_host_function_without_returning_result(function_name, parameters, return_type)?;
         self.get_host_return_value::<T>()
     }
 

src/hyperlight_guest_bin/src/host_comm.rs

@@ -44,13 +44,13 @@ where
     handle.call_host_function::<T>(function_name, parameters, return_type)
 }
 
-pub fn call_host_function_without_returning(
+pub fn call_host_function_without_returning_result(
     function_name: &str,
     parameters: Option<Vec<ParameterValue>>,
     return_type: ReturnType,
 ) -> Result<()> {
     let handle = unsafe { GUEST_HANDLE };
-    handle.call_host_function_without_returning(function_name, parameters, return_type)
+    handle.call_host_function_without_returning_result(function_name, parameters, return_type)
 }
 
 pub fn get_host_return_value<T: TryFrom<ReturnValue>>() -> Result<T> {

src/hyperlight_guest_capi/src/dispatch.rs

@@ -10,7 +10,7 @@ use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_guest::error::{HyperlightGuestError, Result};
 use hyperlight_guest_bin::guest_function::definition::GuestFunctionDefinition;
 use hyperlight_guest_bin::guest_function::register::GuestFunctionRegister;
-use hyperlight_guest_bin::host_comm::call_host_function_without_returning;
+use hyperlight_guest_bin::host_comm::call_host_function_without_returning_result;
 
 use crate::types::{FfiFunctionCall, FfiVec};
 static mut REGISTERED_C_GUEST_FUNCTIONS: GuestFunctionRegister = GuestFunctionRegister::new();
@@ -95,6 +95,6 @@ pub extern "C" fn hl_call_host_function(function_call: &FfiFunctionCall) {
 
     // Use the non-generic internal implementation
     // The C API will then call specific getter functions to fetch the properly typed return value
-    let _ = call_host_function_without_returning(&func_name, Some(parameters), return_type)
+    let _ = call_host_function_without_returning_result(&func_name, Some(parameters), return_type)
         .expect("Failed to call host function");
 }

src/tests/rust_guests/simpleguest/src/main.rs

@@ -45,7 +45,9 @@ use hyperlight_guest::error::{HyperlightGuestError, Result};
 use hyperlight_guest::exit::{abort_with_code, abort_with_code_and_message};
 use hyperlight_guest_bin::guest_function::definition::GuestFunctionDefinition;
 use hyperlight_guest_bin::guest_function::register::register_function;
-use hyperlight_guest_bin::host_comm::{call_host_function, call_host_function_without_returning};
+use hyperlight_guest_bin::host_comm::{
+    call_host_function, call_host_function_without_returning_result,
+};
 use hyperlight_guest_bin::memory::malloc;
 use hyperlight_guest_bin::{guest_logger, MIN_STACK_ADDRESS};
 use log::{error, LevelFilter};
@@ -1194,9 +1196,13 @@ fn fuzz_host_function(func: FunctionCall) -> Result<Vec<u8>> {
 
     // Because we do not know at compile time the actual return type of the host function to be called
     // we cannot use the `call_host_function<T>` generic function.
-    // We need to use the `call_host_function_without_returning` function that does not retrieve the return
+    // We need to use the `call_host_function_without_returning_result` function that does not retrieve the return
     // value
-    call_host_function_without_returning(&host_func_name, Some(params), func.expected_return_type)
-        .expect("failed to call host function");
+    call_host_function_without_returning_result(
+        &host_func_name,
+        Some(params),
+        func.expected_return_type,
+    )
+    .expect("failed to call host function");
     Ok(get_flatbuffer_result(()))
 }