[component_macro] Add host_bindgen!() and guest_bindgen!()

This adds a proc-macro crate that exposes the bindings code generation
from hyperlight_component_util as macros suitable for using WIT to
define a hyperlight host<->guest interface.

Signed-off-by: Lucy Menon <[email protected]>

Author: syntactically

Cargo.toml

@@ -14,6 +14,7 @@ members = [
     "fuzz",
     "src/hyperlight_guest_bin",
     "src/hyperlight_component_util",
+    "src/hyperlight_component_macro",
 ]
 # Guests have custom linker flags, so we need to exclude them from the workspace
 exclude = [
@@ -38,6 +39,7 @@ hyperlight-guest = { path = "src/hyperlight_guest", version = "0.5.1", default-f
 hyperlight-guest-bin = { path = "src/hyperlight_guest_bin", version = "0.5.1", default-features = false }
 hyperlight-testing = { path = "src/hyperlight_testing", default-features = false }
 hyperlight-component-util = { path = "src/hyperlight_component_util" }
+hyperlight-component-macro = { path = "src/hyperlight_component_macro" }
 
 [workspace.lints.rust]
 unsafe_op_in_unsafe_fn = "deny"

src/hyperlight_component_macro/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "hyperlight-component-macro"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+readme.workspace = true
+description = """
+Procedural macros to generate Hyperlight host and guest bindings from component types
+"""
+
+[lib]
+name = "hyperlight_component_macro"
+proc-macro = true
+
+[dependencies]
+wasmparser = { version = "0.224.0" }
+quote = { version = "1.0.38" }
+proc-macro2 = { version = "1.0.93" }
+syn = { version = "2.0.96" }
+itertools = { version = "0.14.0" }
+prettyplease = { version = "0.2.31" }
+hyperlight-component-util = { workspace = true }

src/hyperlight_component_macro/src/lib.rs

@@ -0,0 +1,74 @@
+/*
+Copyright 2024 The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+ */
+
+extern crate proc_macro;
+
+use hyperlight_component_util::*;
+
+/// Create host bindings for the wasm component type in the file
+/// passed in (or `$WIT_WORLD`, if nothing is passed in). This will
+/// produce all relevant types and trait implementations for the
+/// component type, as well as functions allowing the component to be
+/// instantiated inside a sandbox.
+///
+/// This includes both a primitive `register_host_functions`, which can
+/// be used to directly register the host functions on any sandbox
+/// (and which can easily be used with Hyperlight-Wasm), as well as an
+/// `instantiate()` method on the component trait that makes
+/// instantiating the sandbox particularly ergonomic in core
+/// Hyperlight.
+#[proc_macro]
+pub fn host_bindgen(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let path: Option<syn::LitStr> = syn::parse_macro_input!(input as Option<syn::LitStr>);
+    let path = path
+        .map(|x| x.value().into())
+        .unwrap_or_else(|| std::env::var_os("WIT_WORLD").unwrap());
+    util::read_wit_type_from_file(path, |kebab_name, ct| {
+        let decls = emit::run_state(false, false, |s| {
+            rtypes::emit_toplevel(s, &kebab_name, ct);
+            host::emit_toplevel(s, &kebab_name, ct);
+        });
+        util::emit_decls(decls).into()
+    })
+}
+
+/// Create the hyperlight_guest_init() function (which should be
+/// called in hyperlight_main()) for the wasm component type in the
+/// file passed in (or `$WIT_WORLD`, if nothing is passed in). This
+/// function registers Hyperlight functions for component exports
+/// (which are implemented by calling into the trait provided) and
+/// implements the relevant traits for a trivial Host type (by calling
+/// into the Hyperlight host).
+#[proc_macro]
+pub fn guest_bindgen(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let path: Option<syn::LitStr> = syn::parse_macro_input!(input as Option<syn::LitStr>);
+    let path = path
+        .map(|x| x.value().into())
+        .unwrap_or_else(|| std::env::var_os("WIT_WORLD").unwrap());
+    util::read_wit_type_from_file(path, |kebab_name, ct| {
+        let decls = emit::run_state(true, false, |s| {
+            // Emit type/trait definitions for all instances in the world
+            rtypes::emit_toplevel(s, &kebab_name, ct);
+            // Emit the host/guest function registrations
+            guest::emit_toplevel(s, &kebab_name, ct);
+        });
+        // Use util::emit_decls() to choose between emitting the token
+        // stream directly and emitting an include!() pointing at a
+        // temporary file, depending on whether the user has requested
+        // a debug temporary file be created.
+        util::emit_decls(decls).into()
+    })
+}

src/hyperlight_host/Cargo.toml

@@ -102,6 +102,7 @@ metrics-util = "0.19.1"
 metrics-exporter-prometheus = "0.17.0"
 tracing-tracy = "0.11.4"
 serde_json = "1.0"
+hyperlight-component-macro = { workspace = true }
 
 [target.'cfg(windows)'.dev-dependencies]
 windows = { version = "0.61", features = [