Add Rust support for fallible resource constructors. (#1360)

And C support came along for free.
See: WebAssembly/component-model#550

C++, C# & Moonbit are not supported yet.

Author: badeend

Cargo.lock

@@ -33,13 +33,13 @@ prettyplease = "0.2.20"
 syn = { version = "2.0.89", features = ["printing"] }
 futures = "0.3.31"
 
-wat = "1.236.0"
-wasmparser = "0.236.0"
-wasm-encoder = "0.236.0"
-wasm-metadata = { version = "0.236.0", default-features = false }
-wit-parser = "0.236.0"
-wit-component = "0.236.0"
-wasm-compose = "0.236.0"
+wat = "1.237.0"
+wasmparser = "0.237.0"
+wasm-encoder = "0.237.0"
+wasm-metadata = { version = "0.237.0", default-features = false }
+wit-parser = "0.237.0"
+wit-component = "0.237.0"
+wasm-compose = "0.237.0"
 
 wit-bindgen-core = { path = 'crates/core', version = '0.44.0' }
 wit-bindgen-c = { path = 'crates/c', version = '0.44.0' }

Cargo.toml

@@ -1,4 +1,7 @@
-use crate::{int_repr, to_rust_ident, Identifier, InterfaceGenerator, RustFlagsRepr};
+use crate::{
+    classify_constructor_return_type, int_repr, to_rust_ident, ConstructorReturnType, Identifier,
+    InterfaceGenerator, RustFlagsRepr,
+};
 use heck::*;
 use std::fmt::Write as _;
 use std::mem;
@@ -876,14 +879,24 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                         None
                     }
                     FunctionKind::Constructor(ty) => {
+                        let return_type =
+                            classify_constructor_return_type(resolve, *ty, &func.result);
                         let ty = resolve.types[*ty]
                             .name
                             .as_deref()
                             .unwrap()
                             .to_upper_camel_case();
-                        let call = format!("{ty}::new(T::new");
-                        self.push_str(&call);
-                        Some(ty)
+
+                        match return_type {
+                            ConstructorReturnType::Self_ => {
+                                self.push_str(&format!("{ty}::new(T::new"));
+                            }
+                            ConstructorReturnType::Result { .. } => {
+                                self.push_str(&format!("T::new"));
+                            }
+                        }
+
+                        Some((ty, return_type))
                     }
                 };
                 self.push_str("(");
@@ -908,8 +921,12 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 if *async_ {
                     self.push_str(".await");
                 }
-                if constructor_type.is_some() {
-                    self.push_str(")");
+                match constructor_type {
+                    Some((_, ConstructorReturnType::Self_)) => self.push_str(")"),
+                    Some((ty, ConstructorReturnType::Result { .. })) => {
+                        self.push_str(&format!(".map({ty}::new)"))
+                    }
+                    None => {}
                 }
                 self.push_str("\n};\n");
             }

crates/rust/src/bindgen.rs

@@ -1,7 +1,8 @@
 use crate::bindgen::{FunctionBindgen, POINTER_SIZE_EXPRESSION};
 use crate::{
-    full_wit_type_name, int_repr, to_rust_ident, to_upper_camel_case, wasm_type, FnSig, Identifier,
-    InterfaceName, Ownership, RuntimeItem, RustFlagsRepr, RustWasm, TypeGeneration,
+    classify_constructor_return_type, full_wit_type_name, int_repr, to_rust_ident,
+    to_upper_camel_case, wasm_type, ConstructorReturnType, FnSig, Identifier, InterfaceName,
+    Ownership, RuntimeItem, RustFlagsRepr, RustWasm, TypeGeneration,
 };
 use anyhow::Result;
 use heck::*;
@@ -1363,10 +1364,20 @@ unsafe fn call_import(_params: Self::ParamsLower, _results: *mut u8) -> u32 {{
 
     fn print_signature(&mut self, func: &Function, params_owned: bool, sig: &FnSig) -> Vec<String> {
         let params = self.print_docs_and_params(func, params_owned, sig);
-        if let FunctionKind::Constructor(_) = &func.kind {
-            self.push_str(" -> Self")
+        self.push_str(" -> ");
+        if let FunctionKind::Constructor(resource_id) = &func.kind {
+            match classify_constructor_return_type(&self.resolve, *resource_id, &func.result) {
+                ConstructorReturnType::Self_ => {
+                    self.push_str("Self");
+                }
+                ConstructorReturnType::Result { err } => {
+                    self.push_str("Result<Self, ");
+                    self.print_result_type(&err);
+                    self.push_str("> where Self: Sized");
+                }
+            }
         } else {
-            self.print_results(&func.result);
+            self.print_result_type(&func.result);
         }
         params
     }
@@ -1482,9 +1493,7 @@ unsafe fn call_import(_params: Self::ParamsLower, _results: *mut u8) -> u32 {{
         params
     }
 
-    fn print_results(&mut self, result: &Option<Type>) {
-        self.push_str(" -> ");
-
+    fn print_result_type(&mut self, result: &Option<Type>) {
         match result {
             None => {
                 self.push_str("()");

crates/rust/src/interface.rs

@@ -1787,3 +1787,63 @@ fn full_wit_type_name(resolve: &Resolve, id: TypeId) -> String {
         None => type_def.name.clone().unwrap(),
     }
 }
+
+enum ConstructorReturnType {
+    /// Resource constructor is infallible. E.g.:
+    /// ```wit
+    /// resource R {
+    ///    constructor(..);
+    /// }
+    /// ```
+    Self_,
+
+    /// Resource constructor is fallible. E.g.:
+    /// ```wit
+    /// resource R {
+    ///    constructor(..) -> result<R, err>;
+    /// }
+    /// ```
+    Result { err: Option<Type> },
+}
+
+fn classify_constructor_return_type(
+    resolve: &Resolve,
+    resource_id: TypeId,
+    result: &Option<Type>,
+) -> ConstructorReturnType {
+    fn classify(
+        resolve: &Resolve,
+        resource_id: TypeId,
+        result: &Option<Type>,
+    ) -> Option<ConstructorReturnType> {
+        let resource_id = dealias(resolve, resource_id);
+        let typedef = match result.as_ref()? {
+            Type::Id(id) => &resolve.types[dealias(resolve, *id)],
+            _ => return None,
+        };
+
+        match &typedef.kind {
+            TypeDefKind::Handle(Handle::Own(id)) if dealias(resolve, *id) == resource_id => {
+                Some(ConstructorReturnType::Self_)
+            }
+            TypeDefKind::Result(Result_ { ok, err }) => {
+                let ok_typedef = match ok.as_ref()? {
+                    Type::Id(id) => &resolve.types[dealias(resolve, *id)],
+                    _ => return None,
+                };
+
+                match &ok_typedef.kind {
+                    TypeDefKind::Handle(Handle::Own(id))
+                        if dealias(resolve, *id) == resource_id =>
+                    {
+                        Some(ConstructorReturnType::Result { err: *err })
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+
+    classify(resolve, resource_id, result).expect("invalid constructor")
+}