Add the ability to skip bindings in Rust (#422)

This commit adds a `skip` attribute and CLI argument for skipping
generation of bindings for a set of named functions. This can be useful
when the generated bindings can't be used for a reason such as they're
to high-level, instead allowing applications to manually define
functions which work with the raw inputs of the canonical ABI.

Author: alexcrichton

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

@@ -1,4 +1,5 @@
 use heck::*;
+use std::collections::HashSet;
 use std::fmt::Write as _;
 use std::io::{Read, Write};
 use std::mem;
@@ -18,6 +19,7 @@ struct RustWasm {
     src: Source,
     opts: Opts,
     exports: Vec<Source>,
+    skip: HashSet<String>,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -62,11 +64,16 @@ pub struct Opts {
     /// format `export_{world_name}!`.
     #[cfg_attr(feature = "clap", arg(long))]
     pub export_macro_name: Option<String>,
+
+    /// Names of functions to skip generating bindings for.
+    #[cfg_attr(feature = "clap", arg(long))]
+    pub skip: Vec<String>,
 }
 
 impl Opts {
     pub fn build(self) -> Box<dyn WorldGenerator> {
         let mut r = RustWasm::new();
+        r.skip = self.skip.iter().cloned().collect();
         r.opts = self;
         Box::new(r)
     }
@@ -243,6 +250,9 @@ impl InterfaceGenerator<'_> {
         let camel = name.to_upper_camel_case();
         uwriteln!(self.src, "pub trait {camel} {{");
         for func in self.iface.functions.iter() {
+            if self.gen.skip.contains(&func.name) {
+                continue;
+            }
             let mut sig = FnSig::default();
             sig.private = true;
             self.print_signature(func, TypeMode::Owned, &sig);
@@ -289,6 +299,10 @@ impl InterfaceGenerator<'_> {
     }
 
     fn generate_guest_import(&mut self, func: &Function) {
+        if self.gen.skip.contains(&func.name) {
+            return;
+        }
+
         let sig = FnSig::default();
         let param_mode = TypeMode::AllBorrowed("'_");
         match &func.kind {
@@ -325,13 +339,16 @@ impl InterfaceGenerator<'_> {
     }
 
     fn generate_guest_export(&mut self, module_name: &str, func: &Function, default_export: bool) {
+        if self.gen.skip.contains(&func.name) {
+            return;
+        }
+
         let module_name = module_name.to_snake_case();
         let trait_bound = module_name.to_upper_camel_case();
         let iface_snake = self.iface.name.to_snake_case();
         let name_snake = func.name.to_snake_case();
         let export_name = self.iface.core_export_name(default_export, func);
         let mut macro_src = Source::default();
-
         // Generate, simultaneously, the actual lifting/lowering function within
         // the original module (`call_{name_snake}`) as well as the function
         // which will ge exported from the wasm module itself through the export

crates/gen-guest-rust/tests/codegen.rs

@@ -174,3 +174,22 @@ mod macro_name {
 
     jam!(Component);
 }
+
+mod skip {
+    wit_bindgen_guest_rust::generate!({
+        export_str["exports"]: "
+            foo: func()
+            bar: func()
+        ",
+        name: "baz",
+        skip: ["foo"],
+    });
+
+    struct Component;
+
+    impl exports::Exports for Component {
+        fn bar() {}
+    }
+
+    export_baz!(Component);
+}

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

@@ -1,6 +1,7 @@
 use proc_macro::TokenStream;
 use syn::{
     parse::{Parse, ParseStream, Result},
+    punctuated::Punctuated,
     LitStr, Token,
 };
 use wit_bindgen_gen_guest_rust::Opts;
@@ -16,6 +17,7 @@ mod kw {
     syn::custom_keyword!(raw_strings);
     syn::custom_keyword!(macro_call_prefix);
     syn::custom_keyword!(export_macro_name);
+    syn::custom_keyword!(skip);
 }
 
 enum Opt {
@@ -24,6 +26,7 @@ enum Opt {
     RawStrings,
     MacroCallPrefix(LitStr),
     ExportMacroName(LitStr),
+    Skip(Vec<LitStr>),
 }
 
 impl Parse for Opt {
@@ -46,6 +49,13 @@ impl Parse for Opt {
             input.parse::<kw::export_macro_name>()?;
             input.parse::<Token![:]>()?;
             Ok(Opt::ExportMacroName(input.parse()?))
+        } else if l.peek(kw::skip) {
+            input.parse::<kw::skip>()?;
+            input.parse::<Token![:]>()?;
+            let contents;
+            syn::bracketed!(contents in input);
+            let list = Punctuated::<_, Token![,]>::parse_terminated(&contents)?;
+            Ok(Opt::Skip(list.iter().cloned().collect()))
         } else {
             Err(l.error())
         }
@@ -60,6 +70,7 @@ impl wit_bindgen_rust_macro_shared::Configure<Opts> for Opt {
             Opt::RawStrings => opts.raw_strings = true,
             Opt::MacroCallPrefix(prefix) => opts.macro_call_prefix = Some(prefix.value()),
             Opt::ExportMacroName(name) => opts.export_macro_name = Some(name.value()),
+            Opt::Skip(list) => opts.skip.extend(list.iter().map(|i| i.value())),
         }
     }
 }