Add support for WIT fallible constructors

This implements: WebAssembly/component-model#550

Author: badeend

crates/wasmparser/src/validator/component.rs

@@ -4410,8 +4410,9 @@ impl ComponentNameContext {
             | ComponentNameKind::Dependency(_)
             | ComponentNameKind::Hash(_) => {}
 
-            // Constructors must return `(own $resource)` and the `$resource`
-            // must be named within this context to match `rname`
+            // Constructors must return `(own $resource)` or
+            // `(result (own $Tresource))` and the `$resource` must be named
+            // within this context to match `rname`.
             ComponentNameKind::Constructor(rname) => {
                 let ty = func()?;
                 let ty = match ty.result {
@@ -4422,12 +4423,19 @@ impl ComponentNameContext {
                     ComponentValType::Primitive(_) => None,
                     ComponentValType::Type(ty) => match &types[ty] {
                         ComponentDefinedType::Own(id) => Some(id),
+                        ComponentDefinedType::Result {
+                            ok: Some(ComponentValType::Type(ok)),
+                            ..
+                        } => match &types[*ok] {
+                            ComponentDefinedType::Own(id) => Some(id),
+                            _ => None,
+                        },
                         _ => None,
                     },
                 };
                 let resource = match resource {
                     Some(id) => id,
-                    None => bail!(offset, "function should return `(own $T)`"),
+                    None => bail!(offset, "function should return `(own $T)` or `(result (own $T))`"),
                 };
                 self.validate_resource_name(*resource, rname, offset)?;
             }

crates/wit-component/src/printing.rs

@@ -371,15 +371,30 @@ impl<O: Output> WitPrinter<O> {
         }
         self.output.str(")");
 
-        // constructors don't have their results printed
-        if let FunctionKind::Constructor(_) = func.kind {
-            return Ok(());
+        self.print_function_result(resolve, func)?;
+
+        Ok(())
+    }
+
+    fn print_function_result(&mut self, resolve: &Resolve, func: &Function) -> Result<()> {
+        // Don't print the return type for constructors that return an owned
+        // handle of themselves:
+        if let FunctionKind::Constructor(containing_res_id) = func.kind {
+            if let Some(Type::Id(id)) = &func.result {
+                let ty = &resolve.types[*id];
+                if let TypeDefKind::Handle(Handle::Own(return_res_id)) = ty.kind {
+                    if containing_res_id == return_res_id {
+                        return Ok(());
+                    }
+                }
+            }
         }
 
         if let Some(ty) = &func.result {
             self.output.str(" -> ");
             self.print_type_name(resolve, ty)?;
         }
+
         Ok(())
     }
 

crates/wit-component/tests/components/fallible-constructor/component.wat

@@ -0,0 +1,73 @@
+(component
+  (type (;0;)
+    (instance
+      (export (;0;) "a" (type (sub resource)))
+      (type (;1;) (own 0))
+      (type (;2;) (result 1 (error u32)))
+      (type (;3;) (func (result 2)))
+      (export (;0;) "[constructor]a" (func (type 3)))
+    )
+  )
+  (import "foo" (instance (;0;) (type 0)))
+  (core module (;0;)
+    (type (;0;) (func (param i32)))
+    (import "foo" "[constructor]a" (func (;0;) (type 0)))
+    (import "foo" "[resource-drop]a" (func (;1;) (type 0)))
+    (memory (;0;) 1)
+    (export "memory" (memory 0))
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+      (processed-by "my-fake-bindgen" "123.45")
+    )
+  )
+  (core module (;1;)
+    (type (;0;) (func (param i32)))
+    (table (;0;) 1 1 funcref)
+    (export "0" (func $"indirect-foo-[constructor]a"))
+    (export "$imports" (table 0))
+    (func $"indirect-foo-[constructor]a" (;0;) (type 0) (param i32)
+      local.get 0
+      i32.const 0
+      call_indirect (type 0)
+    )
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core module (;2;)
+    (type (;0;) (func (param i32)))
+    (import "" "0" (func (;0;) (type 0)))
+    (import "" "$imports" (table (;0;) 1 1 funcref))
+    (elem (;0;) (i32.const 0) func 0)
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core instance (;0;) (instantiate 1))
+  (alias core export 0 "0" (core func (;0;)))
+  (alias export 0 "a" (type (;1;)))
+  (core func (;1;) (canon resource.drop 1))
+  (core instance (;1;)
+    (export "[constructor]a" (func 0))
+    (export "[resource-drop]a" (func 1))
+  )
+  (core instance (;2;) (instantiate 0
+      (with "foo" (instance 1))
+    )
+  )
+  (alias core export 2 "memory" (core memory (;0;)))
+  (alias core export 0 "$imports" (core table (;0;)))
+  (alias export 0 "[constructor]a" (func (;0;)))
+  (core func (;2;) (canon lower (func 0) (memory 0)))
+  (core instance (;3;)
+    (export "$imports" (table 0))
+    (export "0" (func 2))
+  )
+  (core instance (;4;) (instantiate 2
+      (with "" (instance 3))
+    )
+  )
+  (@producers
+    (processed-by "wit-component" "$CARGO_PKG_VERSION")
+  )
+)

crates/wit-component/tests/components/fallible-constructor/component.wit.print

@@ -0,0 +1,9 @@
+package root:component;
+
+world root {
+  import foo: interface {
+    resource a {
+      constructor() -> result<a, u32>;
+    }
+  }
+}

crates/wit-component/tests/components/fallible-constructor/module.wat

@@ -0,0 +1,5 @@
+(module
+  (import "foo" "[constructor]a" (func (param i32)))
+  (import "foo" "[resource-drop]a" (func (param i32)))
+  (memory (export "memory") 1)
+)

crates/wit-component/tests/components/fallible-constructor/module.wit

@@ -0,0 +1,9 @@
+package foo:bar;
+
+world module {
+  import foo: interface {
+    resource a {
+      constructor() -> result<a, u32>;
+    }
+  }
+}

crates/wit-component/tests/interfaces/resources.wat

@@ -152,13 +152,18 @@
           (alias export 2 "bar" (type (;5;)))
           (import "bar" (type (;6;) (eq 5)))
           (import "a" (type (;7;) (sub resource)))
-          (type (;8;) (own 7))
-          (type (;9;) (func (result 8)))
-          (import "[constructor]a" (func (;0;) (type 9)))
-          (export (;1;) "x" (func (type 9)))
-          (type (;10;) (own 6))
-          (type (;11;) (func (result 10)))
-          (export (;2;) "y" (func (type 11)))
+          (import "b" (type (;8;) (sub resource)))
+          (type (;9;) (own 7))
+          (type (;10;) (func (result 9)))
+          (import "[constructor]a" (func (;0;) (type 10)))
+          (type (;11;) (own 8))
+          (type (;12;) (result 11 (error string)))
+          (type (;13;) (func (result 12)))
+          (import "[constructor]b" (func (;1;) (type 13)))
+          (export (;2;) "x" (func (type 10)))
+          (type (;14;) (own 6))
+          (type (;15;) (func (result 14)))
+          (export (;3;) "y" (func (type 15)))
         )
       )
       (export (;0;) "foo:bar/some-world" (component (type 0)))

crates/wit-component/tests/interfaces/resources.wit

@@ -27,6 +27,10 @@ world some-world {
     constructor();
   }
 
+  resource b {
+    constructor() -> result<b, string>;
+  }
+
   export x: func() -> a;
   export y: func() -> bar;
 

crates/wit-component/tests/interfaces/resources.wit.print

@@ -65,6 +65,10 @@ world some-world {
     constructor();
   }
 
+  resource b {
+    constructor() -> result<b, string>;
+  }
+
   export x: func() -> a;
   export y: func() -> bar;
 }

crates/wit-encoder/src/from_parser.rs

@@ -397,8 +397,6 @@ impl<'a> Converter<'a> {
     ) -> Option<ResourceFunc> {
         // skip first argument for methods, as they're just `self`.
         let mut skip_first_param = false;
-        // constructors can't return anything
-        let mut with_returns = true;
         let mut method = match func.kind {
             wit_parser::FunctionKind::Freestanding
             | wit_parser::FunctionKind::AsyncFreestanding => return None,
@@ -423,7 +421,6 @@ impl<'a> Converter<'a> {
                 if id != resource_id {
                     return None;
                 }
-                with_returns = false;
                 ResourceFunc::constructor()
             }
         };
@@ -433,9 +430,7 @@ impl<'a> Converter<'a> {
             method.params_mut().items_mut().remove(0);
         }
 
-        if with_returns {
-            method.set_result(func.result.as_ref().map(|ty| self.convert_type(ty)));
-        }
+        method.set_result(func.result.as_ref().map(|ty| self.convert_type(ty)));
 
         Some(method)
     }