Implement support for exported resources in bindgen! (#7050)

* Implement support for exported resources in `bindgen!`

This commit updates the `wasmtime::component::bindgen!` to support
exported resources. Exported resources are themselves always modeled as
`ResourceAny` at runtime and are required to perform dynamic type checks
to ensure that the right type of resource is passed in. Exported
resources have their own `GuestXXX` structure exported to namespace all
of their methods. Otherwise, like imports, there's not a whole lot of
special treatment of exported resources.

* Work around `heck` issue

Looks like `to_snake_case` behaves differently if the `unicode` feature
is enabled or not so bypass that entirely.

crates/component-macro/tests/codegen/resources-export.wit

@@ -0,0 +1,43 @@
+package foo:foo
+
+world w {
+  export simple-export
+  export export-using-import
+
+  export export-using-export1
+  export export-using-export2
+}
+
+interface simple-export {
+  resource a {
+    constructor()
+    static-a: static func() -> u32
+    method-a: func() -> u32
+  }
+}
+
+interface export-using-import {
+  use transitive-import.{y}
+  resource a {
+    constructor(y: y)
+    static-a: static func() -> y
+    method-a: func(y: y) -> y
+  }
+}
+
+interface transitive-import {
+  resource y
+}
+
+interface export-using-export1 {
+  resource a {
+    constructor()
+  }
+}
+
+interface export-using-export2 {
+  use export-using-export1.{a}
+  resource b {
+    constructor(a: a)
+  }
+}

crates/wit-bindgen/src/lib.rs

@@ -169,7 +169,13 @@ impl Opts {
 }
 
 impl Wasmtime {
-    fn name_interface(&mut self, resolve: &Resolve, id: InterfaceId, name: &WorldKey) -> bool {
+    fn name_interface(
+        &mut self,
+        resolve: &Resolve,
+        id: InterfaceId,
+        name: &WorldKey,
+        is_export: bool,
+    ) -> bool {
         let with_name = resolve.name_world_key(name);
         let entry = if let Some(remapped_path) = self.opts.with.get(&with_name) {
             let name = format!("__with_name{}", self.with_name_counter);
@@ -193,6 +199,11 @@ impl Wasmtime {
                     )
                 }
             };
+            let path = if is_export {
+                format!("exports::{path}")
+            } else {
+                path
+            };
             InterfaceName {
                 remapped: false,
                 path,
@@ -239,7 +250,7 @@ impl Wasmtime {
             }
             WorldItem::Interface(id) => {
                 gen.gen.interface_last_seen_as_import.insert(*id, true);
-                if gen.gen.name_interface(resolve, *id, name) {
+                if gen.gen.name_interface(resolve, *id, name, false) {
                     return;
                 }
                 gen.current_interface = Some((*id, name, false));
@@ -301,15 +312,15 @@ impl Wasmtime {
                 assert!(gen.src.is_empty());
                 self.exports.funcs.push(body);
                 (
-                    func.name.to_snake_case(),
+                    func_field_name(resolve, func),
                     "wasmtime::component::Func".to_string(),
                     getter,
                 )
             }
             WorldItem::Type(_) => unreachable!(),
             WorldItem::Interface(id) => {
                 gen.gen.interface_last_seen_as_import.insert(*id, false);
-                gen.gen.name_interface(resolve, *id, name);
+                gen.gen.name_interface(resolve, *id, name, true);
                 gen.current_interface = Some((*id, name, true));
                 gen.types(*id);
                 let iface = &resolve.interfaces[*id];
@@ -320,18 +331,11 @@ impl Wasmtime {
                 let camel = to_rust_upper_camel_case(iface_name);
                 uwriteln!(gen.src, "pub struct {camel} {{");
                 for (_, func) in iface.functions.iter() {
-                    match func.kind {
-                        FunctionKind::Freestanding => {
-                            uwriteln!(
-                                gen.src,
-                                "{}: wasmtime::component::Func,",
-                                func.name.to_snake_case()
-                            );
-                        }
-                        // Resource methods are handled separately in
-                        // `type_resource`.
-                        _ => {}
-                    }
+                    uwriteln!(
+                        gen.src,
+                        "{}: wasmtime::component::Func,",
+                        func_field_name(resolve, func)
+                    );
                 }
                 uwriteln!(gen.src, "}}");
 
@@ -346,35 +350,56 @@ impl Wasmtime {
                 );
                 let mut fields = Vec::new();
                 for (_, func) in iface.functions.iter() {
-                    match func.kind {
-                        FunctionKind::Freestanding => {
-                            let (name, getter) = gen.extract_typed_function(func);
-                            uwriteln!(gen.src, "let {name} = {getter};");
-                            fields.push(name);
-                        }
-                        // Resource methods are handled separately in
-                        // `type_resource`.
-                        _ => {}
-                    }
+                    let (name, getter) = gen.extract_typed_function(func);
+                    uwriteln!(gen.src, "let {name} = {getter};");
+                    fields.push(name);
                 }
                 uwriteln!(gen.src, "Ok({camel} {{");
                 for name in fields {
                     uwriteln!(gen.src, "{name},");
                 }
                 uwriteln!(gen.src, "}})");
                 uwriteln!(gen.src, "}}");
+
+                let mut resource_methods = IndexMap::new();
+
                 for (_, func) in iface.functions.iter() {
                     match func.kind {
                         FunctionKind::Freestanding => {
                             gen.define_rust_guest_export(resolve, Some(name), func);
                         }
-                        // Resource methods are handled separately in
-                        // `type_resource`.
-                        _ => {}
+                        FunctionKind::Method(id)
+                        | FunctionKind::Constructor(id)
+                        | FunctionKind::Static(id) => {
+                            resource_methods.entry(id).or_insert(Vec::new()).push(func);
+                        }
                     }
                 }
+
+                for (id, _) in resource_methods.iter() {
+                    let name = resolve.types[*id].name.as_ref().unwrap();
+                    let snake = name.to_snake_case();
+                    let camel = name.to_upper_camel_case();
+                    uwriteln!(
+                        gen.src,
+                        "pub fn {snake}(&self) -> Guest{camel}<'_> {{
+                            Guest{camel} {{ funcs: self }}
+                        }}"
+                    );
+                }
+
                 uwriteln!(gen.src, "}}");
 
+                for (id, methods) in resource_methods {
+                    let resource_name = resolve.types[id].name.as_ref().unwrap();
+                    let camel = resource_name.to_upper_camel_case();
+                    uwriteln!(gen.src, "impl Guest{camel}<'_> {{");
+                    for method in methods {
+                        gen.define_rust_guest_export(resolve, Some(name), method);
+                    }
+                    uwriteln!(gen.src, "}}");
+                }
+
                 let module = &gen.src[..];
                 let snake = iface_name.to_snake_case();
 
@@ -841,6 +866,13 @@ impl<'a> InterfaceGenerator<'a> {
         }
     }
 
+    fn types_imported(&self) -> bool {
+        match self.current_interface {
+            Some((_, _, is_export)) => !is_export,
+            None => true,
+        }
+    }
+
     fn types(&mut self, id: InterfaceId) {
         for (name, id) in self.resolve.interfaces[id].types.iter() {
             self.define_type(name, *id);
@@ -887,51 +919,72 @@ impl<'a> InterfaceGenerator<'a> {
             .expect("resources are required to be named")
             .to_upper_camel_case();
 
-        self.rustdoc(docs);
-        uwriteln!(self.src, "pub enum {camel} {{}}");
+        if self.types_imported() {
+            self.rustdoc(docs);
+            uwriteln!(self.src, "pub enum {camel} {{}}");
 
-        if self.gen.opts.async_.maybe_async() {
-            uwriteln!(self.src, "#[wasmtime::component::__internal::async_trait]")
-        }
+            if self.gen.opts.async_.maybe_async() {
+                uwriteln!(self.src, "#[wasmtime::component::__internal::async_trait]")
+            }
 
-        uwriteln!(self.src, "pub trait Host{camel} {{");
+            uwriteln!(self.src, "pub trait Host{camel} {{");
+
+            let functions = match resource.owner {
+                TypeOwner::World(id) => self.resolve.worlds[id]
+                    .imports
+                    .values()
+                    .filter_map(|item| match item {
+                        WorldItem::Function(f) => Some(f),
+                        _ => None,
+                    })
+                    .collect(),
+                TypeOwner::Interface(id) => self.resolve.interfaces[id]
+                    .functions
+                    .values()
+                    .collect::<Vec<_>>(),
+                TypeOwner::None => {
+                    panic!("A resource must be owned by a world or interface");
+                }
+            };
 
-        let functions = match resource.owner {
-            TypeOwner::World(id) => self.resolve.worlds[id]
-                .imports
-                .values()
-                .filter_map(|item| match item {
-                    WorldItem::Function(f) => Some(f),
-                    _ => None,
-                })
-                .collect(),
-            TypeOwner::Interface(id) => self.resolve.interfaces[id]
-                .functions
-                .values()
-                .collect::<Vec<_>>(),
-            TypeOwner::None => {
-                panic!("A resource must be owned by a world or interface");
-            }
-        };
+            for func in functions {
+                match func.kind {
+                    FunctionKind::Method(resource)
+                    | FunctionKind::Static(resource)
+                    | FunctionKind::Constructor(resource)
+                        if id == resource => {}
+                    _ => continue,
+                }
 
-        for func in functions {
-            match func.kind {
-                FunctionKind::Method(resource)
-                | FunctionKind::Static(resource)
-                | FunctionKind::Constructor(resource)
-                    if id == resource => {}
-                _ => continue,
+                self.generate_function_trait_sig(func);
             }
 
-            self.generate_function_trait_sig(func);
-        }
+            uwrite!(
+                self.src,
+                "fn drop(&mut self, rep: wasmtime::component::Resource<{camel}>) -> wasmtime::Result<()>;");
 
-        uwrite!(
-            self.src,
-            "fn drop(&mut self, rep: wasmtime::component::Resource<{camel}>) -> wasmtime::Result<()>;"
-        );
+            uwriteln!(self.src, "}}");
+        } else {
+            let iface_name = match self.current_interface.unwrap().1 {
+                WorldKey::Name(name) => name.to_upper_camel_case(),
+                WorldKey::Interface(i) => self.resolve.interfaces[*i]
+                    .name
+                    .as_ref()
+                    .unwrap()
+                    .to_upper_camel_case(),
+            };
+            self.rustdoc(docs);
+            uwriteln!(
+                self.src,
+                "
+                    pub type {camel} = wasmtime::component::ResourceAny;
 
-        uwriteln!(self.src, "}}");
+                    pub struct Guest{camel}<'a> {{
+                        funcs: &'a {iface_name},
+                    }}
+                "
+            );
+        }
     }
 
     fn type_record(&mut self, id: TypeId, _name: &str, record: &Record, docs: &Docs) {
@@ -1668,7 +1721,7 @@ impl<'a> InterfaceGenerator<'a> {
 
     fn extract_typed_function(&mut self, func: &Function) -> (String, String) {
         let prev = mem::take(&mut self.src);
-        let snake = func.name.to_snake_case();
+        let snake = func_field_name(self.resolve, func);
         uwrite!(self.src, "*__exports.typed_func::<(");
         for (_, ty) in func.params.iter() {
             self.print_ty(ty, TypeMode::AllBorrowed("'_"));
@@ -1709,7 +1762,7 @@ impl<'a> InterfaceGenerator<'a> {
         uwrite!(
             self.src,
             "pub {async_} fn call_{}<S: wasmtime::AsContextMut>(&self, mut store: S, ",
-            func.name.to_snake_case(),
+            func.item_name().to_snake_case(),
         );
 
         for (i, param) in func.params.iter().enumerate() {
@@ -1758,10 +1811,14 @@ impl<'a> InterfaceGenerator<'a> {
             self.print_ty(ty, TypeMode::Owned);
             self.push_str(", ");
         }
+        let projection_to_func = match &func.kind {
+            FunctionKind::Freestanding => "",
+            _ => ".funcs",
+        };
         uwriteln!(
             self.src,
-            ")>::new_unchecked(self.{})",
-            func.name.to_snake_case()
+            ")>::new_unchecked(self{projection_to_func}.{})",
+            func_field_name(self.resolve, func),
         );
         self.src.push_str("};\n");
         self.src.push_str("let (");
@@ -1923,6 +1980,30 @@ fn rust_function_name(func: &Function) -> String {
     }
 }
 
+fn func_field_name(resolve: &Resolve, func: &Function) -> String {
+    let mut name = String::new();
+    match func.kind {
+        FunctionKind::Method(id) => {
+            name.push_str("method-");
+            name.push_str(resolve.types[id].name.as_ref().unwrap());
+            name.push_str("-");
+        }
+        FunctionKind::Static(id) => {
+            name.push_str("static-");
+            name.push_str(resolve.types[id].name.as_ref().unwrap());
+            name.push_str("-");
+        }
+        FunctionKind::Constructor(id) => {
+            name.push_str("constructor-");
+            name.push_str(resolve.types[id].name.as_ref().unwrap());
+            name.push_str("-");
+        }
+        FunctionKind::Freestanding => {}
+    }
+    name.push_str(func.item_name());
+    name.to_snake_case()
+}
+
 fn get_resources<'a>(resolve: &'a Resolve, id: InterfaceId) -> impl Iterator<Item = &'a str> + 'a {
     resolve.interfaces[id]
         .types