[Rust] flip the generation default for non-local interfaces (#972)

* Flip the default for non-local interfaces

Signed-off-by: Ryan Levick <[email protected]>

* Add option to generate all interfaces

Signed-off-by: Ryan Levick <[email protected]>

* Track generated interfaces are used as well

Signed-off-by: Ryan Levick <[email protected]>

* Fix rustdoc errors

Signed-off-by: Ryan Levick <[email protected]>

---------

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

crates/c/src/lib.rs

@@ -176,7 +176,7 @@ impl WorldGenerator for C {
         name: &WorldKey,
         id: InterfaceId,
         _files: &mut Files,
-    ) {
+    ) -> Result<()> {
         let wasm_import_module = resolve.name_world_key(name);
         let mut gen = self.interface(resolve, true, Some(&wasm_import_module));
         gen.interface = Some((id, name));
@@ -192,6 +192,8 @@ impl WorldGenerator for C {
         }
 
         gen.gen.src.append(&gen.src);
+
+        Ok(())
     }
 
     fn import_funcs(

crates/core/src/lib.rs

@@ -37,7 +37,9 @@ pub trait WorldGenerator {
         for (name, import) in world.imports.iter() {
             match import {
                 WorldItem::Function(f) => funcs.push((unwrap_name(name), f)),
-                WorldItem::Interface { id, .. } => self.import_interface(resolve, name, *id, files),
+                WorldItem::Interface { id, .. } => {
+                    self.import_interface(resolve, name, *id, files)?
+                }
                 WorldItem::Type(id) => types.push((unwrap_name(name), *id)),
             }
         }
@@ -91,7 +93,7 @@ pub trait WorldGenerator {
         name: &WorldKey,
         iface: InterfaceId,
         files: &mut Files,
-    );
+    ) -> Result<()>;
 
     /// Called before any exported interfaces are generated.
     fn pre_export_interface(&mut self, resolve: &Resolve, files: &mut Files) -> Result<()> {

crates/csharp/src/lib.rs

@@ -196,7 +196,7 @@ impl WorldGenerator for CSharp {
         key: &WorldKey,
         id: InterfaceId,
         _files: &mut Files,
-    ) {
+    ) -> Result<()> {
         let name = interface_name(self, resolve, key, Direction::Import);
         self.interface_names.insert(id, name.clone());
         let mut gen = self.interface(resolve, &name, Direction::Import);
@@ -232,6 +232,8 @@ impl WorldGenerator for CSharp {
         gen.define_interface_types(id);
 
         gen.add_interface_fragment(false);
+
+        Ok(())
     }
 
     fn import_funcs(

crates/go/src/lib.rs

@@ -169,7 +169,7 @@ impl WorldGenerator for TinyGo {
         name: &WorldKey,
         id: InterfaceId,
         _files: &mut Files,
-    ) {
+    ) -> Result<()> {
         let name_raw = &resolve.name_world_key(name);
         self.src
             .push_str(&format!("// Import functions from {name_raw}\n"));
@@ -187,6 +187,8 @@ impl WorldGenerator for TinyGo {
         let preamble = mem::take(&mut gen.preamble);
         self.src.push_str(&src);
         self.preamble.append_src(&preamble);
+
+        Ok(())
     }
 
     fn import_funcs(

crates/guest-rust/macro/src/lib.rs

@@ -7,7 +7,7 @@ use syn::parse::{Error, Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::{braced, token, Token};
 use wit_bindgen_core::wit_parser::{PackageId, Resolve, UnresolvedPackage, WorldId};
-use wit_bindgen_rust::{Opts, Ownership};
+use wit_bindgen_rust::{Opts, Ownership, WithOption};
 
 #[proc_macro]
 pub fn generate(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -99,6 +99,9 @@ impl Parse for Config {
                             .collect()
                     }
                     Opt::With(with) => opts.with.extend(with),
+                    Opt::GenerateAll => {
+                        opts.with.generate_by_default = true;
+                    }
                     Opt::TypeSectionSuffix(suffix) => {
                         opts.type_section_suffix = Some(suffix.value());
                     }
@@ -234,6 +237,7 @@ mod kw {
     syn::custom_keyword!(export_prefix);
     syn::custom_keyword!(additional_derives);
     syn::custom_keyword!(with);
+    syn::custom_keyword!(generate_all);
     syn::custom_keyword!(type_section_suffix);
     syn::custom_keyword!(disable_run_ctors_once_workaround);
     syn::custom_keyword!(default_bindings_module);
@@ -284,7 +288,8 @@ enum Opt {
     ExportPrefix(syn::LitStr),
     // Parse as paths so we can take the concrete types/macro names rather than raw strings
     AdditionalDerives(Vec<syn::Path>),
-    With(HashMap<String, String>),
+    With(HashMap<String, WithOption>),
+    GenerateAll,
     TypeSectionSuffix(syn::LitStr),
     DisableRunCtorsOnceWorkaround(syn::LitBool),
     DefaultBindingsModule(syn::LitStr),
@@ -390,6 +395,9 @@ impl Parse for Opt {
             let fields: Punctuated<_, Token![,]> =
                 contents.parse_terminated(with_field_parse, Token![,])?;
             Ok(Opt::With(HashMap::from_iter(fields.into_iter())))
+        } else if l.peek(kw::generate_all) {
+            input.parse::<kw::generate_all>()?;
+            Ok(Opt::GenerateAll)
         } else if l.peek(kw::type_section_suffix) {
             input.parse::<kw::type_section_suffix>()?;
             input.parse::<Token![:]>()?;
@@ -427,7 +435,7 @@ impl Parse for Opt {
     }
 }
 
-fn with_field_parse(input: ParseStream<'_>) -> Result<(String, String)> {
+fn with_field_parse(input: ParseStream<'_>) -> Result<(String, WithOption)> {
     let interface = input.parse::<syn::LitStr>()?.value();
     input.parse::<Token![:]>()?;
     let start = input.span();
@@ -438,6 +446,10 @@ fn with_field_parse(input: ParseStream<'_>) -> Result<(String, String)> {
         .join(path.segments.last().unwrap().ident.span())
         .unwrap_or(start);
 
+    if path.is_ident("generate") {
+        return Ok((interface, WithOption::Generate));
+    }
+
     let mut buf = String::new();
     let append = |buf: &mut String, segment: syn::PathSegment| -> Result<()> {
         if !segment.arguments.is_none() {
@@ -467,7 +479,7 @@ fn with_field_parse(input: ParseStream<'_>) -> Result<(String, String)> {
         append(&mut buf, segment)?;
     }
 
-    Ok((interface, buf))
+    Ok((interface, WithOption::Path(buf)))
 }
 
 /// Format a valid Rust string

crates/guest-rust/src/examples/_1_interface_imports.rs

@@ -24,4 +24,9 @@ crate::generate!({
     "#,
 
     path: "[email protected]",
+
+    // specify that this interface dependency should be generated as well.
+    with: {
+        "wasi:cli/[email protected]": generate,
+    }
 });

crates/guest-rust/src/examples/_3_world_exports.rs

@@ -37,4 +37,11 @@ crate::generate!({
 
     // provided to specify the path to `wasi:*` dependencies referenced above.
     path: "[email protected]",
+
+    // specify that these interface dependencies should be generated as well.
+    with: {
+        "wasi:random/[email protected]": generate,
+        "wasi:clocks/[email protected]": generate,
+        "wasi:io/[email protected]": generate
+    }
 });

crates/guest-rust/src/lib.rs

@@ -668,25 +668,30 @@
 ///     // By default this set is empty.
 ///     additional_derives: [PartialEq, Eq, Hash, Clone],
 ///
-///     // When generating bindings for imports it might be the case that
-///     // bindings were already generated in a different crate. For example
-///     // if your world refers to WASI types then the `wasi` crate already
-///     // has generated bindings for all WASI types and structures. In this
+///     // When generating bindings for interfaces that are not defined in the
+///     // same package as `world`, this option can be used to either generate
+///     // those bindings or point to already generated bindings.
+///     // For example, if your world refers to WASI types then the `wasi` crate
+///     // already has generated bindings for all WASI types and structures. In this
 ///     // situation the key `with` here can be used to use those types
 ///     // elsewhere rather than regenerating types.
 ///     //
-///     // The `with` key here only works for interfaces referred to by imported
-///     // functions. Additionally it only supports replacing types at the
-///     // interface level at this time.
+///     // If, however, your world refers to interfaces for which you don't have
+///     // already generated bindings then you can use the special `generate` value
+///     // to have those bindings generated.
 ///     //
-///     // When an interface is specified here no bindings will be generated at
-///     // all. It's assumed bindings are fully generated upstream. This is an
+///     // The `with` key only supports replacing types at the interface level
+///     // at this time.
+///     //
+///     // When an interface is specified no bindings will be generated at
+///     // all. It's assumed bindings are fully generated somewhere else. This is an
 ///     // indicator that any further references to types defined in these
 ///     // interfaces should use the upstream paths specified here instead.
 ///     //
 ///     // Any unused keys in this map are considered an error.
 ///     with: {
 ///         "wasi:io/poll": wasi::io::poll,
+///         "some:package/my-interface": generate,
 ///     },
 ///
 ///     // An optional list of function names to skip generating bindings for.

crates/markdown/src/lib.rs

@@ -117,7 +117,7 @@ impl WorldGenerator for Markdown {
         name: &WorldKey,
         id: InterfaceId,
         _files: &mut Files,
-    ) {
+    ) -> Result<()> {
         let name = resolve.name_world_key(name);
         uwriteln!(
             self.src,
@@ -131,6 +131,8 @@ impl WorldGenerator for Markdown {
         gen.push_str("\n");
         gen.types(id);
         gen.funcs(id);
+
+        Ok(())
     }
 
     fn import_funcs(