Closes #651:

- adds support to select a specific world from a WIT file if
  multiple worlds are specified.

Signed-off-by: Shailesh Vashishth <[email protected]>

Author: vshailesh

Justfile

@@ -45,6 +45,7 @@ guests: build-and-move-rust-guests build-and-move-c-guests
 witguest-wit:
     cargo install --locked wasm-tools
     cd src/tests/rust_guests/witguest && wasm-tools component wit guest.wit -w -o interface.wasm
+    cd src/tests/rust_guests/witguest && wasm-tools component wit two_worlds.wit -w -o twoworlds.wasm
 
 build-rust-guests target=default-target features="": (witguest-wit)
     cd src/tests/rust_guests/simpleguest && cargo build {{ if features =="" {''} else if features=="no-default-features" {"--no-default-features" } else {"--no-default-features -F " + features } }} --profile={{ if target == "debug" { "dev" } else { target } }} 

src/hyperlight_component_macro/src/lib.rs

@@ -50,6 +50,8 @@ limitations under the License.
 extern crate proc_macro;
 
 use hyperlight_component_util::*;
+use syn::parse::{Parse, ParseStream};
+use syn::{Ident, LitStr, Result, Token};
 
 /// Create host bindings for the wasm component type in the file
 /// passed in (or `$WIT_WORLD`, if nothing is passed in). This will
@@ -63,14 +65,23 @@ use hyperlight_component_util::*;
 /// `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 _ = env_logger::try_init();
-    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 parsed_bindgen_input = syn::parse_macro_input!(input as BindgenInputParams);
+    let path = parsed_bindgen_input.path.unwrap_or_else(|| {
+        let wit_world_env = std::env::var_os("WIT_WORLD");
+
+        if let Some(env) = wit_world_env {
+            std::path::PathBuf::from(env)
+        } else {
+            std::path::PathBuf::new()
+        }
+    });
+    let world_name = parsed_bindgen_input.world_name;
+
+    util::read_wit_type_from_file(path, world_name, |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);
@@ -89,11 +100,19 @@ pub fn host_bindgen(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 #[proc_macro]
 pub fn guest_bindgen(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let _ = env_logger::try_init();
-    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 parsed_bindgen_input = syn::parse_macro_input!(input as BindgenInputParams);
+    let path = parsed_bindgen_input.path.unwrap_or_else(|| {
+        let wit_world_env = std::env::var_os("WIT_WORLD");
+
+        if let Some(env) = wit_world_env {
+            std::path::PathBuf::from(env)
+        } else {
+            std::path::PathBuf::new()
+        }
+    });
+    let world_name = parsed_bindgen_input.world_name;
+
+    util::read_wit_type_from_file(path, world_name, |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);
@@ -107,3 +126,52 @@ pub fn guest_bindgen(input: proc_macro::TokenStream) -> proc_macro::TokenStream
         util::emit_decls(decls).into()
     })
 }
+
+#[derive(Debug)]
+struct BindgenInputParams {
+    world_name: Option<String>,
+    path: Option<std::path::PathBuf>,
+}
+
+impl Parse for BindgenInputParams {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut path = None;
+        let mut world_name = None;
+
+        if input.peek(syn::token::Brace) {
+            let content;
+            syn::braced!(content in input);
+            eprintln!("Content = \n {:?}", content);
+
+            // Parse key-value pairs inside the braces
+            while !content.is_empty() {
+                let key: Ident = content.parse()?;
+                content.parse::<Token![:]>()?;
+
+                match key.to_string().as_str() {
+                    "world_name" => {
+                        let value: LitStr = content.parse()?;
+                        world_name = Some(value.value());
+                    }
+                    "path" => {
+                        let value: LitStr = content.parse()?;
+                        path = Some(std::path::PathBuf::from(value.value()));
+                    }
+                    _ => {
+                        return Err(syn::Error::new(key.span(), format!("Unknown key: {}", key)));
+                    }
+                }
+                // Parse optional comma
+                if content.peek(Token![,]) {
+                    content.parse::<Token![,]>()?;
+                }
+            }
+        } else {
+            let option_path_litstr = input.parse::<Option<syn::LitStr>>()?;
+            if let Some(concrete_path) = option_path_litstr {
+                path = Some(std::path::PathBuf::from(concrete_path.value()));
+            }
+        }
+        Ok(Self { world_name, path })
+    }
+}

src/hyperlight_component_util/src/component.rs

@@ -82,9 +82,10 @@ fn raw_type_export_type<'p, 'a, 'c>(
 /// export.
 pub fn read_component_single_exported_type<'a>(
     items: impl Iterator<Item = wasmparser::Result<Payload<'a>>>,
+    world_name: Option<String>,
 ) -> Component<'a> {
     let mut ctx = Ctx::new(None, false);
-    let mut last_idx = None;
+    let mut picks_one_world_or_last_idx = None;
     for x in items {
         match x {
             Ok(Version { num, encoding, .. }) => {
@@ -112,8 +113,23 @@ pub fn read_component_single_exported_type<'a>(
                         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());
+
+                                // picks the world index if world is passed in the proc_macro
+                                // else picks the index of last type, exported by core module
+                                if world_name.is_some() {
+                                    let world = world_name.clone().unwrap();
+                                    match ce.name {
+                                        wasmparser::ComponentExportName(name) => {
+                                            if name.eq_ignore_ascii_case(&world) {
+                                                picks_one_world_or_last_idx =
+                                                    Some(ctx.types.len() - 1);
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    picks_one_world_or_last_idx = Some(ctx.types.len() - 1);
+                                }
                             }
                         }
                     }
@@ -149,7 +165,8 @@ pub fn read_component_single_exported_type<'a>(
             _ => {}
         }
     }
-    match last_idx {
+
+    match picks_one_world_or_last_idx {
         None => panic!("no exported type"),
         Some(n) => match ctx.types.into_iter().nth(n) {
             Some(Defined::Component(c)) => c,

src/hyperlight_component_util/src/util.rs

@@ -21,6 +21,7 @@ use crate::etypes;
 /// given filename, relative to the cargo manifest directory.
 pub fn read_wit_type_from_file<R, F: FnMut(String, &etypes::Component) -> R>(
     filename: impl AsRef<std::ffi::OsStr>,
+    world_name: Option<String>,
     mut cb: F,
 ) -> R {
     let path = std::path::Path::new(&filename);
@@ -30,7 +31,8 @@ pub fn read_wit_type_from_file<R, F: FnMut(String, &etypes::Component) -> R>(
 
     let bytes = std::fs::read(path).unwrap();
     let i = wasmparser::Parser::new(0).parse_all(&bytes);
-    let ct = crate::component::read_component_single_exported_type(i);
+    // let ct = crate::component::read_component_single_exported_type(i);
+    let ct = crate::component::read_component_single_exported_type(i, world_name);
 
     // because of the two-level encapsulation scheme, we need to look
     // for the single export of the component type that we just read

src/hyperlight_host/tests/wit_test.rs

@@ -426,3 +426,27 @@ mod wit_test {
         drop(guard);
     }
 }
+
+mod pick_world_bindings {
+    hyperlight_component_macro::host_bindgen!({path: "../tests/rust_guests/witguest/twoworlds.wasm", world_name: "firstworld"});
+}
+
+use pick_world_bindings::*;
+
+impl pick_world_bindings::twoworlds::wit::first_import::RecFirstImport {
+    fn new() -> Option<Self> {
+        Some(Self {
+            key: "dummyKey",
+            value: "dummyValue",
+        })
+    }
+}
+
+mod pick_world_binding_test {
+    use crate::pick_world_bindings::twoworlds::wit::first_import::*;
+    #[test]
+    fn test_first_import_instance() {
+        let firstImport = FirstWorldResources::new();
+        assert!(firstImport.is_some());
+    }
+}

src/tests/rust_guests/witguest/two_worlds.wit

@@ -0,0 +1,23 @@
+package twoworlds:wit;
+
+world secondworld {
+  export second-export;
+}
+
+world firstworld {
+    import first-import;
+}
+
+interface second-export {
+  record rec-second-export {
+    key : string,
+    value: string
+  }
+}
+
+interface first-import {
+    record rec-first-import {
+        key: string,
+        value : string
+    }
+}