Fix using Rust types in owned and borrowed contexts (#514)

This pulls in type analysis code from Wasmtime which has a more modern
notion of param/result as owned/borrowed and additionally removes the
need for a `default_param_mode` which caused #513 in the first place.

Closes #513

Author: alexcrichton

crates/bindgen-core/src/lib.rs

@@ -16,12 +16,18 @@ pub struct Types {
 #[derive(Default, Clone, Copy, Debug)]
 pub struct TypeInfo {
     /// Whether or not this type is ever used (transitively) within the
-    /// parameter of a function.
-    pub param: bool,
+    /// parameter of an imported function.
+    ///
+    /// This means that it's used in a context where ownership isn't
+    /// relinquished.
+    pub borrowed: bool,
 
     /// Whether or not this type is ever used (transitively) within the
-    /// result of a function.
-    pub result: bool,
+    /// parameter or result of an export, or the result of an import.
+    ///
+    /// This means that it's used in a context where ownership is required and
+    /// memory management is necessary.
+    pub owned: bool,
 
     /// Whether or not this type is ever used (transitively) within the
     /// error case in the result of a function.
@@ -33,8 +39,8 @@ pub struct TypeInfo {
 
 impl std::ops::BitOrAssign for TypeInfo {
     fn bitor_assign(&mut self, rhs: Self) {
-        self.param |= rhs.param;
-        self.result |= rhs.result;
+        self.borrowed |= rhs.borrowed;
+        self.owned |= rhs.owned;
         self.error |= rhs.error;
         self.has_list |= rhs.has_list;
     }
@@ -45,29 +51,63 @@ impl Types {
         for (t, _) in resolve.types.iter() {
             self.type_id_info(resolve, t);
         }
-        for (_, iface) in resolve.interfaces.iter() {
-            for (_, f) in iface.functions.iter() {
-                self.type_info_func(resolve, f);
-            }
-        }
         for (_, world) in resolve.worlds.iter() {
-            for (_, item) in world.imports.iter().chain(&world.exports) {
+            for (import, (_, item)) in world
+                .imports
+                .iter()
+                .map(|i| (true, i))
+                .chain(world.exports.iter().map(|i| (false, i)))
+            {
                 match item {
                     WorldItem::Function(f) => {
-                        self.type_info_func(resolve, f);
+                        self.type_info_func(resolve, f, import);
                     }
-                    WorldItem::Interface(_) | WorldItem::Type(_) => {}
+                    WorldItem::Interface(id) => {
+                        for (_, f) in resolve.interfaces[*id].functions.iter() {
+                            self.type_info_func(resolve, f, import);
+                        }
+                    }
+                    WorldItem::Type(_) => {}
                 }
             }
         }
     }
 
-    fn type_info_func(&mut self, resolve: &Resolve, f: &Function) {
-        for (_, ty) in f.params.iter() {
-            self.set_param_result_ty(resolve, ty, true, false, false);
+    fn type_info_func(&mut self, resolve: &Resolve, func: &Function, import: bool) {
+        let mut live = LiveTypes::default();
+        for (_, ty) in func.params.iter() {
+            self.type_info(resolve, ty);
+            live.add_type(resolve, ty);
+        }
+        for id in live.iter() {
+            let info = self.type_info.get_mut(&id).unwrap();
+            if import {
+                info.borrowed = true;
+            } else {
+                info.owned = true;
+            }
         }
-        for ty in f.results.iter_types() {
-            self.set_param_result_ty(resolve, ty, false, true, false);
+        let mut live = LiveTypes::default();
+        for ty in func.results.iter_types() {
+            self.type_info(resolve, ty);
+            live.add_type(resolve, ty);
+        }
+        for id in live.iter() {
+            self.type_info.get_mut(&id).unwrap().owned = true;
+        }
+
+        for ty in func.results.iter_types() {
+            let id = match ty {
+                Type::Id(id) => *id,
+                _ => continue,
+            };
+            let err = match &resolve.types[id].kind {
+                TypeDefKind::Result(Result_ { err, .. }) => err,
+                _ => continue,
+            };
+            if let Some(Type::Id(id)) = err {
+                self.type_info.get_mut(&id).unwrap().error = true;
+            }
         }
     }
 
@@ -146,110 +186,6 @@ impl Types {
             None => TypeInfo::default(),
         }
     }
-
-    fn set_param_result_id(
-        &mut self,
-        resolve: &Resolve,
-        ty: TypeId,
-        param: bool,
-        result: bool,
-        error: bool,
-    ) {
-        match &resolve.types[ty].kind {
-            TypeDefKind::Record(r) => {
-                for field in r.fields.iter() {
-                    self.set_param_result_ty(resolve, &field.ty, param, result, error)
-                }
-            }
-            TypeDefKind::Tuple(t) => {
-                for ty in t.types.iter() {
-                    self.set_param_result_ty(resolve, ty, param, result, error)
-                }
-            }
-            TypeDefKind::Flags(_) => {}
-            TypeDefKind::Enum(_) => {}
-            TypeDefKind::Variant(v) => {
-                for case in v.cases.iter() {
-                    self.set_param_result_optional_ty(
-                        resolve,
-                        case.ty.as_ref(),
-                        param,
-                        result,
-                        error,
-                    )
-                }
-            }
-            TypeDefKind::List(ty) | TypeDefKind::Type(ty) | TypeDefKind::Option(ty) => {
-                self.set_param_result_ty(resolve, ty, param, result, error)
-            }
-            TypeDefKind::Result(r) => {
-                self.set_param_result_optional_ty(resolve, r.ok.as_ref(), param, result, error);
-                self.set_param_result_optional_ty(resolve, r.err.as_ref(), param, result, result);
-            }
-            TypeDefKind::Union(u) => {
-                for case in u.cases.iter() {
-                    self.set_param_result_ty(resolve, &case.ty, param, result, error)
-                }
-            }
-            TypeDefKind::Future(ty) => {
-                self.set_param_result_optional_ty(resolve, ty.as_ref(), param, result, error)
-            }
-            TypeDefKind::Stream(stream) => {
-                self.set_param_result_optional_ty(
-                    resolve,
-                    stream.element.as_ref(),
-                    param,
-                    result,
-                    error,
-                );
-                self.set_param_result_optional_ty(
-                    resolve,
-                    stream.end.as_ref(),
-                    param,
-                    result,
-                    error,
-                );
-            }
-            TypeDefKind::Unknown => unreachable!(),
-        }
-    }
-
-    fn set_param_result_ty(
-        &mut self,
-        resolve: &Resolve,
-        ty: &Type,
-        param: bool,
-        result: bool,
-        error: bool,
-    ) {
-        match ty {
-            Type::Id(id) => {
-                self.type_id_info(resolve, *id);
-                let info = self.type_info.get_mut(id).unwrap();
-                if (param && !info.param) || (result && !info.result) || (error && !info.error) {
-                    info.param = info.param || param;
-                    info.result = info.result || result;
-                    info.error = info.error || error;
-                    self.set_param_result_id(resolve, *id, param, result, error);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn set_param_result_optional_ty(
-        &mut self,
-        resolve: &Resolve,
-        ty: Option<&Type>,
-        param: bool,
-        result: bool,
-        error: bool,
-    ) {
-        match ty {
-            Some(ty) => self.set_param_result_ty(resolve, ty, param, result, error),
-            None => (),
-        }
-    }
 }
 
 #[derive(Default)]

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

@@ -1115,21 +1115,7 @@ impl InterfaceGenerator<'_> {
                 let ty = &self.resolve.types[*id];
                 match &ty.name {
                     Some(name) => {
-                        match ty.owner {
-                            TypeOwner::Interface(owner) => {
-                                self.src.print(
-                                    stype,
-                                    &self.gen.interface_names[&owner].to_snake_case(),
-                                );
-                                self.src.print(stype, "_");
-                            }
-                            TypeOwner::World(owner) => {
-                                self.src
-                                    .print(stype, &self.resolve.worlds[owner].name.to_snake_case());
-                                self.src.print(stype, "_");
-                            }
-                            TypeOwner::None => {}
-                        }
+                        self.print_owner_namespace(stype, *id);
 
                         self.src.print(stype, &name.to_snake_case());
                         self.src.print(stype, "_t");
@@ -1149,6 +1135,25 @@ impl InterfaceGenerator<'_> {
         }
     }
 
+    fn print_owner_namespace(&mut self, stype: SourceType, id: TypeId) {
+        let ty = &self.resolve.types[id];
+        match ty.owner {
+            TypeOwner::Interface(owner) => {
+                self.src
+                    .print(stype, &self.gen.interface_names[&owner].to_snake_case());
+                self.src.print(stype, "_");
+            }
+            TypeOwner::World(owner) => {
+                self.src
+                    .print(stype, &self.resolve.worlds[owner].name.to_snake_case());
+                self.src.print(stype, "_");
+            }
+            TypeOwner::None => {
+                self.print_namespace(stype);
+            }
+        }
+    }
+
     fn print_ty_name(&mut self, stype: SourceType, ty: &Type) {
         match ty {
             Type::Bool => self.src.print(stype, "bool"),
@@ -1457,6 +1462,9 @@ impl InterfaceGenerator<'_> {
                 self.src.h_helpers(&self.gen.world.to_snake_case());
                 self.src.h_helpers("_");
             }
+            Type::Id(id) => {
+                self.print_owner_namespace(SourceType::HHelpers, *id);
+            }
             _ => {
                 self.print_namespace(SourceType::HHelpers);
             }

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

@@ -86,7 +86,6 @@ impl RustWasm {
         &'a mut self,
         wasm_import_module: Option<&'a str>,
         resolve: &'a Resolve,
-        default_param_mode: TypeMode,
         in_import: bool,
     ) -> InterfaceGenerator<'a> {
         let mut sizes = SizeAlign::default();
@@ -100,7 +99,6 @@ impl RustWasm {
             gen: self,
             sizes,
             resolve,
-            default_param_mode,
             return_pointer_area_size: 0,
             return_pointer_area_align: 0,
         }
@@ -126,7 +124,7 @@ impl WorldGenerator for RustWasm {
     ) {
         let prev = self.interface_names.insert(id, name.to_snake_case());
         assert!(prev.is_none());
-        let mut gen = self.interface(Some(name), resolve, TypeMode::AllBorrowed("'a"), true);
+        let mut gen = self.interface(Some(name), resolve, true);
         gen.current_interface = Some(id);
         gen.types(id);
 
@@ -144,7 +142,7 @@ impl WorldGenerator for RustWasm {
         funcs: &[(&str, &Function)],
         _files: &mut Files,
     ) {
-        let mut gen = self.interface(Some("$root"), resolve, TypeMode::AllBorrowed("'a"), true);
+        let mut gen = self.interface(Some("$root"), resolve, true);
 
         for (_, func) in funcs {
             gen.generate_guest_import(func);
@@ -162,7 +160,7 @@ impl WorldGenerator for RustWasm {
         _files: &mut Files,
     ) {
         self.interface_names.insert(id, name.to_snake_case());
-        let mut gen = self.interface(None, resolve, TypeMode::Owned, false);
+        let mut gen = self.interface(None, resolve, false);
         gen.current_interface = Some(id);
         gen.types(id);
         gen.generate_exports(name, Some(name), resolve.interfaces[id].functions.values());
@@ -177,7 +175,7 @@ impl WorldGenerator for RustWasm {
         _files: &mut Files,
     ) {
         let name = &resolve.worlds[world].name;
-        let mut gen = self.interface(None, resolve, TypeMode::Owned, false);
+        let mut gen = self.interface(None, resolve, false);
         gen.generate_exports(name, None, funcs.iter().map(|f| f.1));
         let src = gen.finish();
         self.src.push_str(&src);
@@ -190,7 +188,7 @@ impl WorldGenerator for RustWasm {
         types: &[(&str, TypeId)],
         _files: &mut Files,
     ) {
-        let mut gen = self.interface(None, resolve, TypeMode::Owned, false);
+        let mut gen = self.interface(None, resolve, false);
         for (name, ty) in types {
             gen.define_type(name, *ty);
         }
@@ -321,7 +319,6 @@ struct InterfaceGenerator<'a> {
     gen: &'a mut RustWasm,
     wasm_import_module: Option<&'a str>,
     resolve: &'a Resolve,
-    default_param_mode: TypeMode,
     return_pointer_area_size: usize,
     return_pointer_area_align: usize,
 }
@@ -634,10 +631,6 @@ impl<'a> RustGenerator<'a> for InterfaceGenerator<'a> {
         "wit_bindgen::rt::string::String"
     }
 
-    fn default_param_mode(&self) -> TypeMode {
-        self.default_param_mode
-    }
-
     fn push_str(&mut self, s: &str) {
         self.src.push_str(s);
     }