[wit-bindgen] provide more control over type ownership

crates/component-macro/src/bindgen.rs

@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 use syn::parse::{Error, Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::{braced, token, Ident, Token};
-use wasmtime_wit_bindgen::{Opts, TrappableError};
+use wasmtime_wit_bindgen::{Opts, Ownership, TrappableError};
 use wit_parser::{PackageId, Resolve, UnresolvedPackage, WorldId};
 
 pub struct Config {
@@ -73,7 +73,7 @@ impl Parse for Config {
                     Opt::Tracing(val) => opts.tracing = val,
                     Opt::Async(val) => opts.async_ = val,
                     Opt::TrappableErrorType(val) => opts.trappable_error_type = val,
-                    Opt::DuplicateIfNecessary(val) => opts.duplicate_if_necessary = val,
+                    Opt::Ownership(val) => opts.ownership = val,
                     Opt::Interfaces(s) => {
                         if inline.is_some() {
                             return Err(Error::new(s.span(), "cannot specify a second source"));
@@ -168,7 +168,7 @@ mod kw {
     syn::custom_keyword!(tracing);
     syn::custom_keyword!(trappable_error_type);
     syn::custom_keyword!(world);
-    syn::custom_keyword!(duplicate_if_necessary);
+    syn::custom_keyword!(ownership);
     syn::custom_keyword!(interfaces);
     syn::custom_keyword!(with);
 }
@@ -180,7 +180,7 @@ enum Opt {
     Tracing(bool),
     Async(bool),
     TrappableErrorType(Vec<TrappableError>),
-    DuplicateIfNecessary(bool),
+    Ownership(Ownership),
     Interfaces(syn::LitStr),
     With(HashMap<String, String>),
 }
@@ -208,12 +208,44 @@ impl Parse for Opt {
             input.parse::<Token![async]>()?;
             input.parse::<Token![:]>()?;
             Ok(Opt::Async(input.parse::<syn::LitBool>()?.value))
-        } else if l.peek(kw::duplicate_if_necessary) {
-            input.parse::<kw::duplicate_if_necessary>()?;
+        } else if l.peek(kw::ownership) {
+            input.parse::<kw::ownership>()?;
             input.parse::<Token![:]>()?;
-            Ok(Opt::DuplicateIfNecessary(
-                input.parse::<syn::LitBool>()?.value,
-            ))
+            let ownership = input.parse::<syn::Ident>()?;
+            Ok(Opt::Ownership(match ownership.to_string().as_str() {
+                "Owning" => Ownership::Owning,
+                "Borrowing" => Ownership::Borrowing {
+                    duplicate_if_necessary: {
+                        let contents;
+                        braced!(contents in input);
+                        let field = contents.parse::<syn::Ident>()?;
+                        match field.to_string().as_str() {
+                            "duplicate_if_necessary" => {
+                                contents.parse::<Token![:]>()?;
+                                contents.parse::<syn::LitBool>()?.value
+                            }
+                            name => {
+                                return Err(Error::new(
+                                    field.span(),
+                                    format!(
+                                        "unrecognized `Ownership::Borrowing` field: `{name}`; \
+                                         expected `duplicate_if_necessary`"
+                                    ),
+                                ));
+                            }
+                        }
+                    },
+                },
+                name => {
+                    return Err(Error::new(
+                        ownership.span(),
+                        format!(
+                            "unrecognized ownership: `{name}`; \
+                             expected `Owning` or `Borrowing`"
+                        ),
+                    ));
+                }
+            }))
         } else if l.peek(kw::trappable_error_type) {
             input.parse::<kw::trappable_error_type>()?;
             input.parse::<Token![:]>()?;

crates/component-macro/tests/codegen.rs

@@ -14,7 +14,9 @@ macro_rules! gentest {
                 wasmtime::component::bindgen!({
                     path: $path,
                     tracing: true,
-                    duplicate_if_necessary: true,
+                    ownership: Borrowing {
+                        duplicate_if_necessary: true
+                    }
                 });
             }
         }

crates/test-programs/tests/reactor.rs

@@ -37,6 +37,9 @@ wasmtime::component::bindgen!({
        "wasi:cli-base/stdout": preview2::wasi::cli_base::stdout,
        "wasi:cli-base/stderr": preview2::wasi::cli_base::stderr,
     },
+    ownership: Borrowing {
+        duplicate_if_necessary: false
+    }
 });
 
 struct ReactorCtx {

crates/wit-bindgen/src/lib.rs

@@ -63,6 +63,25 @@ struct Exports {
     funcs: Vec<String>,
 }
 
+#[derive(Default, Debug, Clone, Copy)]
+pub enum Ownership {
+    /// Generated types will be composed entirely of owning fields, regardless
+    /// of whether they are used as parameters to guest exports or not.
+    #[default]
+    Owning,
+
+    /// Generated types used as parameters to guest exports will be "deeply
+    /// borrowing", i.e. contain references rather than owned values when
+    /// applicable.
+    Borrowing {
+        /// Whether or not to generate "duplicate" type definitions for a single
+        /// WIT type if necessary, for example if it's used as both an import
+        /// and an export, or if it's used both as a parameter to an export and
+        /// a return value from an export.
+        duplicate_if_necessary: bool,
+    },
+}
+
 #[derive(Default, Debug, Clone)]
 pub struct Opts {
     /// Whether or not `rustfmt` is executed to format generated code.
@@ -78,10 +97,8 @@ pub struct Opts {
     /// `result<T, E>` found in WIT.
     pub trappable_error_type: Vec<TrappableError>,
 
-    /// Whether or not to generate "duplicate" type definitions for a single
-    /// WIT type if necessary, for example if it's used as both an import and an
-    /// export.
-    pub duplicate_if_necessary: bool,
+    /// Whether to generate owning or borrowing type definitions.
+    pub ownership: Ownership,
 
     /// Whether or not to generate code for only the interfaces of this wit file or not.
     pub only_interfaces: bool,
@@ -1582,8 +1599,8 @@ impl<'a> RustGenerator<'a> for InterfaceGenerator<'a> {
         self.resolve
     }
 
-    fn duplicate_if_necessary(&self) -> bool {
-        self.gen.opts.duplicate_if_necessary
+    fn ownership(&self) -> Ownership {
+        self.gen.opts.ownership
     }
 
     fn path_to_interface(&self, interface: InterfaceId) -> Option<String> {

crates/wit-bindgen/src/rust.rs

@@ -1,4 +1,4 @@
-use crate::types::TypeInfo;
+use crate::{types::TypeInfo, Ownership};
 use heck::*;
 use std::collections::HashMap;
 use std::fmt::Write;
@@ -17,15 +17,16 @@ pub trait RustGenerator<'a> {
     fn info(&self, ty: TypeId) -> TypeInfo;
     fn path_to_interface(&self, interface: InterfaceId) -> Option<String>;
 
-    /// This, if enabled, will possibly cause types to get duplicate copies to
-    /// get generated of each other. For example a record containing a string
-    /// used both in the import and export context would get one variant
-    /// generated for both.
+    /// This determines whether we generate owning types or (where appopriate)
+    /// borrowing types.
     ///
-    /// If this is disabled then the import context would require the same type
-    /// used for the export context, which has an owned string that might not
-    /// otherwise be necessary.
-    fn duplicate_if_necessary(&self) -> bool;
+    /// For example, when generating a type which is only used as a parameter to
+    /// a guest-exported function, there is no need for it to own its fields.
+    /// However, constructing deeply-nested borrows (e.g. `&[&[&[&str]]]]` for
+    /// `list<list<list<string>>>`) can be very awkward, so by default we
+    /// generate owning types and use only shallow borrowing at the top level
+    /// inside function signatures.
+    fn ownership(&self) -> Ownership;
 
     fn print_ty(&mut self, ty: &Type, mode: TypeMode) {
         match ty {
@@ -188,6 +189,11 @@ pub trait RustGenerator<'a> {
     }
 
     fn print_list(&mut self, ty: &Type, mode: TypeMode) {
+        let next_mode = if matches!(self.ownership(), Ownership::Owning) {
+            TypeMode::Owned
+        } else {
+            mode
+        };
         match mode {
             TypeMode::AllBorrowed(lt) => {
                 self.push_str("&");
@@ -196,12 +202,12 @@ pub trait RustGenerator<'a> {
                     self.push_str(" ");
                 }
                 self.push_str("[");
-                self.print_ty(ty, mode);
+                self.print_ty(ty, next_mode);
                 self.push_str("]");
             }
             TypeMode::Owned => {
                 self.push_str("Vec<");
-                self.print_ty(ty, mode);
+                self.print_ty(ty, next_mode);
                 self.push_str(">");
             }
         }
@@ -225,12 +231,13 @@ pub trait RustGenerator<'a> {
             return Vec::new();
         }
         let mut result = Vec::new();
-        let first_mode = if info.owned || !info.borrowed {
-            TypeMode::Owned
-        } else {
-            assert!(!self.uses_two_names(&info));
-            TypeMode::AllBorrowed("'a")
-        };
+        let first_mode =
+            if info.owned || !info.borrowed || matches!(self.ownership(), Ownership::Owning) {
+                TypeMode::Owned
+            } else {
+                assert!(!self.uses_two_names(&info));
+                TypeMode::AllBorrowed("'a")
+            };
         result.push((self.result_name(ty), first_mode));
         if self.uses_two_names(&info) {
             result.push((self.param_name(ty), TypeMode::AllBorrowed("'a")));
@@ -378,10 +385,21 @@ pub trait RustGenerator<'a> {
     }
 
     fn uses_two_names(&self, info: &TypeInfo) -> bool {
-        info.has_list && info.borrowed && info.owned && self.duplicate_if_necessary()
+        info.has_list
+            && info.borrowed
+            && info.owned
+            && matches!(
+                self.ownership(),
+                Ownership::Borrowing {
+                    duplicate_if_necessary: true
+                }
+            )
     }
 
     fn lifetime_for(&self, info: &TypeInfo, mode: TypeMode) -> Option<&'static str> {
+        if matches!(self.ownership(), Ownership::Owning) {
+            return None;
+        }
         let lt = match mode {
             TypeMode::AllBorrowed(s) => s,
             _ => return None,

crates/wit-bindgen/src/types.rs

@@ -69,11 +69,13 @@ impl Types {
             live.add_type(resolve, ty);
         }
         for id in live.iter() {
-            let info = self.type_info.get_mut(&id).unwrap();
-            if import {
-                info.owned = true;
-            } else {
-                info.borrowed = true;
+            if resolve.types[id].name.is_some() {
+                let info = self.type_info.get_mut(&id).unwrap();
+                if import {
+                    info.owned = true;
+                } else {
+                    info.borrowed = true;
+                }
             }
         }
         let mut live = LiveTypes::default();
@@ -82,7 +84,9 @@ impl Types {
             live.add_type(resolve, ty);
         }
         for id in live.iter() {
-            self.type_info.get_mut(&id).unwrap().owned = true;
+            if resolve.types[id].name.is_some() {
+                self.type_info.get_mut(&id).unwrap().owned = true;
+            }
         }
 
         for ty in func.results.iter_types() {

tests/all/component_model/bindgen.rs

@@ -7,6 +7,7 @@ use wasmtime::{
     Store,
 };
 
+mod ownership;
 mod results;
 
 mod no_imports {