[component_util] Add Component Model elaboration/bindgen utilities

This commit adds a general implementation of WebAssembly Component
Model type elaboration, closely derived from the formal
specification. It also adds a number of functions which can generate
Rust binding code from appropriately-structured (roughly: WIT-like)
component types.

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

Author: syntactically

Cargo.toml

@@ -8,6 +8,7 @@ default-members = [
 members = [
     "src/hyperlight_guest_capi",
     "fuzz",
+    "src/hyperlight_component_util",
 ]
 # Guests have custom linker flags, so we need to exclude them from the workspace
 exclude = [
@@ -30,6 +31,7 @@ hyperlight-common = { path = "src/hyperlight_common", version = "0.2.0", default
 hyperlight-host = { path = "src/hyperlight_host", version = "0.2.0", default-features = false }
 hyperlight-guest = { path = "src/hyperlight_guest", version = "0.2.0", default-features = false }
 hyperlight-testing = { path = "src/hyperlight_testing", default-features = false }
+hyperlight-component-util = { path = "src/hyperlight_component_util" }
 
 [workspace.lints.rust]
 unsafe_op_in_unsafe_fn = "deny"

src/hyperlight_component_util/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "hyperlight-component-util"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+readme.workspace = true
+description = """
+Shared implementation for the procedural macros that generate Hyperlight host and guest bindings from component types
+"""
+
+[lib]
+name = "hyperlight_component_util"
+
+[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" }

src/hyperlight_component_util/src/component.rs

@@ -0,0 +1,78 @@
+//! Just enough component parsing support to get at the actual types
+
+use wasmparser::{
+    ComponentExternalKind,
+    ComponentType,
+    ComponentTypeRef,
+    Payload,
+    Payload::{
+        Version,
+        ComponentExportSection,
+        ComponentTypeSection,
+    },
+};
+
+use crate::etypes::{Ctx, Component, Defined};
+
+fn raw_type_export_type<'p, 'a, 'c>(
+    ctx: &'c Ctx<'p, 'a>,
+    ce: &'c wasmparser::ComponentExport<'a>
+) -> &'c Defined<'a> {
+    match ce.ty {
+        Some(ComponentTypeRef::Component(n)) => {
+            match ctx.types.iter().nth(n as usize) {
+                Some(t) => return t,
+                t => panic!("bad component type 1 {:?}", t),
+            }
+        }
+        None => {
+            match ctx.types.iter().nth(ce.index as usize) {
+                Some(t) => return &t,
+                t => panic!("bad component type 2 {:?}", t),
+            }
+        }
+        _ => panic!("non-component ascribed type"),
+    }
+}
+
+pub fn read_component_single_exported_type<'a>(
+    items: impl Iterator<Item = wasmparser::Result<Payload<'a>, >>
+) -> Component<'a> {
+    let mut ctx = Ctx::new(None, false);
+    let mut last_idx = None;
+    for x in items {
+        match x {
+            Ok(Version{..}) => (),
+            Ok(ComponentTypeSection(ts)) => {
+                for t in ts {
+                    match t {
+                        Ok(ComponentType::Component(ct)) => {
+                            let ct_ = ctx.elab_component(&ct);
+                            ctx.types.push(Defined::Component(ct_.unwrap()));
+                        }
+                        _ => panic!("non-component type"),
+                    }
+                }
+            },
+            Ok(ComponentExportSection(es)) => {
+                for e in es {
+                    match e {
+                        Err(_) => panic!("invalid export section"),
+                        Ok(ce) => if ce.kind == ComponentExternalKind::Type {
+                            last_idx = Some(ctx.types.len());
+                            ctx.types.push(raw_type_export_type(&ctx, &ce).clone());
+                        }
+                    }
+                }
+            },
+            _ => {},
+        }
+    }
+    match last_idx {
+        None => panic!("no exported type"),
+        Some(n) => match ctx.types.into_iter().nth(n) {
+            Some(Defined::Component(c)) => c,
+            _ => panic!("final export is not component"),
+        }
+    }
+}