Fix host call with no return type

Signed-off-by: James Sturtevant <jstur@microsoft.com>

Author: jsturtevant

Justfile

@@ -57,9 +57,9 @@ fmt-check:
 fmt:
     rustup toolchain install nightly -c rustfmt
     cargo +nightly fmt --all
-    cd src/rust_wasm_samples &&  cargo +nightly fmt
-    cd src/wasi_samples &&  cargo +nightly fmt
-    cd src/wasm_runtime && cargo +nightly fmt
+    cd src/rust_wasm_samples &&  cargo +nightly fmt -v --all
+    cd src/wasi_samples &&  cargo +nightly fmt -v --all
+    cd src/wasm_runtime && cargo +nightly fmt -v --all
 
 clippy target=default-target: (check target)
     cargo clippy --profile={{ if target == "debug" {"dev"} else { target } }} --all-targets --all-features -- -D warnings

src/hyperlight_wasm/examples/wasi_examples/main.rs

@@ -1,3 +1,6 @@
+#![allow(renamed_and_removed_lints)]
+#![allow(unused_unit)]
+
 use bindings::wasi_sample::example::Adder;
 use examples_common::get_wasm_module_path;
 
@@ -21,6 +24,7 @@ impl Default for State {
 
 impl bindings::wasi_sample::example::Host for State {
     fn r#print(&mut self, message: alloc::string::String) {
+        assert_eq!("42", message);
         println!("Logged from component: {message}");
     }
 
@@ -62,6 +66,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.
 //

src/wasi_samples/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_wasi_sample_example_adder_cabi {
@@ -136,7 +143,10 @@ pub mod exports {
                         (export_name = "cabi_post_wasi-sample:example/adder#call-host")]
                         unsafe extern "C" fn _post_return_call_host(arg0 : * mut u8,) {
                         unsafe { $($path_to_types)*:: __post_return_call_host::<$ty >
-                        (arg0) } } };
+                        (arg0) } } #[unsafe (export_name =
+                        "wasi-sample:example/adder#do-something")] unsafe extern "C" fn
+                        export_do_something(arg0 : i32,) { unsafe { $($path_to_types)*::
+                        _export_do_something_cabi::<$ty > (arg0) } } };
                     };
                 }
                 #[doc(hidden)]
@@ -272,17 +282,20 @@ macro_rules! __export_example_impl {
 #[doc(inline)]
 pub(crate) use __export_example_impl as export;
 #[cfg(target_arch = "wasm32")]
-#[unsafe(link_section = "component-type:wit-bindgen:0.41.0:wasi-sample:example:example:encoded world")]
+#[unsafe(
+    link_section = "component-type:wit-bindgen:0.41.0:wasi-sample:example:example:encoded world"
+)]
 #[doc(hidden)]
 #[allow(clippy::octal_escapes)]
-pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 335] = *b"\
-\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xd1\x01\x01A\x02\x01\
+pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 365] = *b"\
+\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xef\x01\x01A\x02\x01\
 A\x04\x01B\x04\x01@\x01\x07messages\x01\0\x04\0\x05print\x01\0\x01@\x01\x05input\
 s\0s\x04\0\x0dhost-function\x01\x01\x03\0\x18wasi-sample:example/host\x05\0\x01B\
-\x04\x01@\x02\x04lefty\x05righty\0y\x04\0\x03add\x01\0\x01@\x01\x05inputs\0s\x04\
-\0\x09call-host\x01\x01\x04\0\x19wasi-sample:example/adder\x05\x01\x04\0\x1bwasi\
--sample:example/example\x04\0\x0b\x0d\x01\0\x07example\x03\0\0\0G\x09producers\x01\
-\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x060.41.0";
+\x06\x01@\x02\x04lefty\x05righty\0y\x04\0\x03add\x01\0\x01@\x01\x05inputs\0s\x04\
+\0\x09call-host\x01\x01\x01@\x01\x06numbery\x01\0\x04\0\x0cdo-something\x01\x02\x04\
+\0\x19wasi-sample:example/adder\x05\x01\x04\0\x1bwasi-sample:example/example\x04\
+\0\x0b\x0d\x01\0\x07example\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dw\
+it-component\x070.227.1\x10wit-bindgen-rust\x060.41.0";
 #[inline(never)]
 #[doc(hidden)]
 pub fn __link_custom_section_describing_imports() {

src/wasi_samples/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/wasi_samples/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 {