Fix host call with no return type

Signed-off-by: James Sturtevant <jsturtevant@gmail.com>

Author: jsturtevant

src/component_sample/src/bindings.rs

@@ -118,9 +118,16 @@ pub mod exports {
                         .cast::<usize>();
                     _rt::cabi_dealloc(l0, l1, 1);
                 }
+                #[doc(hidden)]
+                #[allow(non_snake_case)]
+                pub unsafe fn _export_do_something_cabi<T: Guest>(arg0: i32) {
+                    #[cfg(target_arch = "wasm32")] _rt::run_ctors_once();
+                    T::do_something(arg0 as u32);
+                }
                 pub trait Guest {
                     fn add(left: u32, right: u32) -> u32;
                     fn call_host(input: _rt::String) -> _rt::String;
+                    fn do_something(number: u32) -> ();
                 }
                 #[doc(hidden)]
                 macro_rules! __export_component_sample_example_adder_cabi {

src/component_sample/src/lib.rs

@@ -14,9 +14,12 @@ impl Guest for Component {
 
     fn call_host(input: String) -> String {
         let host_result = host_function(&format!("{} from component", &input));
-        print(&host_result);
         host_result.to_string()
     }
+
+    fn do_something(number: u32) {
+        print(&format!("{number}"));
+    }
 }
 
 bindings::export!(Component with_types_in bindings);

src/component_sample/wit/example.wit

@@ -8,6 +8,7 @@ world example {
 interface adder {
   add: func(left: u32, right: u32) -> u32;
   call-host: func(input: string) -> string;
+  do-something: func(number: u32);
 }
 
 interface host {

src/hyperlight_wasm/examples/component_example/main.rs

@@ -25,6 +25,7 @@ impl Default for State {
 
 impl bindings::component_sample::example::Host for State {
     fn r#print(&mut self, message: alloc::string::String) {
+        assert_eq!("42", message);
         println!("Logged from component: {message}");
     }
 
@@ -66,6 +67,7 @@ fn main() {
     let result = instance.add(4, 3);
     assert_eq!(7, result);
     println!("Add result is {result}");
+    instance.do_something(42);
 
     let result = instance.call_host("Hello".to_string());
     assert_eq!("Hello from component and the host!", result);

src/hyperlight_wasm_macro/src/wasmguest.rs

@@ -35,6 +35,7 @@ use hyperlight_component_util::hl::{
     emit_hl_unmarshal_result,
 };
 use hyperlight_component_util::{resource, rtypes};
+use proc_macro::Ident;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::ext::IdentExt;
@@ -154,7 +155,6 @@ fn emit_export_extern_decl<'a, 'b, 'c>(
                 .iter()
                 .map(|p| rtypes::emit_value(s, &p.ty))
                 .collect::<Vec<_>>();
-            let rwt = rtypes::emit_func_result(s, &ft.result);
             let (pds, pus) = ft.params.iter().enumerate()
                 .map(|(i, p)| {
                     let id = kebab_to_var(p.name.name);
@@ -166,7 +166,7 @@ fn emit_export_extern_decl<'a, 'b, 'c>(
             let get_instance = path.iter().map(|export| quote! {
                 let instance_idx = Some(instance.get_export(&mut *store, instance_idx.as_ref(), #export).unwrap());
             }).collect::<Vec<_>>();
-            let ret = format_ident!("ret");
+            let (function_call, ret) = emit_wasm_function_call(s, &ft.result, pwts, pus);
             let marshal_result = emit_hl_marshal_result(s, ret.clone(), &ft.result);
             quote! {
                 fn #n(fc: &::hyperlight_common::flatbuffer_wrappers::function_call::FunctionCall) -> ::hyperlight_guest::error::Result<::alloc::vec::Vec<u8>> {
@@ -176,8 +176,7 @@ fn emit_export_extern_decl<'a, 'b, 'c>(
                     let instance_idx = None;
                     #(#get_instance;)*
                     let func_idx = instance.get_export(&mut *store, instance_idx.as_ref(), #nlit).unwrap();
-                    let #ret = instance.get_typed_func::<(#(#pwts,)*), (#rwt,)>(&mut *store, func_idx)?
-                        .call(&mut *store, (#(#pus,)*))?.0;
+                    #function_call
                     ::core::result::Result::Ok(::hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result::<&[u8]>(&#marshal_result))
                 }
                 ::hyperlight_guest_bin::guest_function::register::register_function(
@@ -206,6 +205,34 @@ fn emit_export_extern_decl<'a, 'b, 'c>(
     }
 }
 
+fn emit_wasm_function_call(
+    s: &mut State,
+    result: &etypes::Result,
+    pwts: Vec<TokenStream>,
+    pus: Vec<TokenStream>,
+) -> (TokenStream, proc_macro2::Ident) {
+    let ret = format_ident!("ret");
+
+    // if the result is empty we don't want a return result with `get_typed_func`
+    let rwt = match result {
+        etypes::Result::Named(rs) if rs.is_empty() => {
+            quote! {
+                instance.get_typed_func::<(#(#pwts,)*), ()>(&mut *store, func_idx)?
+                    .call(&mut *store, (#(#pus,)*))?;
+            }
+        }
+        _ => {
+            let r = rtypes::emit_func_result(s, result);
+            quote! {
+                let #ret = instance.get_typed_func::<(#(#pwts,)*), ((#r,))>(&mut *store, func_idx)?
+                    .call(&mut *store, (#(#pus,)*))?.0;
+            }
+        }
+    };
+
+    (rwt, ret)
+}
+
 // Emit code to register each export of the given instance with the
 // wasmtime linker, calling through Hyperlight.
 //