gen-guest-c: define OK constant for scalar enum results (#440)

Author: Guy Bedford

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

@@ -594,9 +594,8 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
     fn type_enum(&mut self, id: TypeId, name: &str, enum_: &Enum, docs: &Docs) {
         let prev = mem::take(&mut self.src.h_defs);
         self.docs(docs);
-        self.src.h_defs("\ntypedef ");
-        self.src.h_defs(int_repr(enum_.tag()));
-        self.src.h_defs(" ");
+        let int_t = int_repr(enum_.tag());
+        uwrite!(self.src.h_defs, "\ntypedef {int_t} ");
         self.print_typedef_target(name);
 
         if enum_.cases.len() > 0 {
@@ -612,6 +611,13 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
                 i,
             );
         }
+        uwriteln!(
+            self.src.h_defs,
+            "#define {}_RESULT_{}_OK {}",
+            self.name.to_shouty_snake_case(),
+            name.to_shouty_snake_case(),
+            int_max_str(enum_.tag())
+        );
 
         self.types
             .insert(id, mem::replace(&mut self.src.h_defs, prev));
@@ -1964,41 +1970,48 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
 
             Instruction::ResultLift { result, ty, .. } => {
-                let (err, err_results) = self.blocks.pop().unwrap();
+                let (mut err, err_results) = self.blocks.pop().unwrap();
                 assert!(err_results.len() == (result.err.is_some() as usize));
-                let (ok, ok_results) = self.blocks.pop().unwrap();
+                let (mut ok, ok_results) = self.blocks.pop().unwrap();
                 assert!(ok_results.len() == (result.ok.is_some() as usize));
 
+                if err.len() > 0 {
+                    err.push_str("\n");
+                }
+                if ok.len() > 0 {
+                    ok.push_str("\n");
+                }
+
                 let result_tmp = self.locals.tmp("result");
                 let set_ok = if let Some(_) = self.gen.get_nonempty_type(result.ok.as_ref()) {
                     let ok_result = &ok_results[0];
-                    format!("{result_tmp}.val.ok = {ok_result};")
+                    format!("{result_tmp}.val.ok = {ok_result};\n")
                 } else {
                     String::new()
                 };
                 let set_err = if let Some(_) = self.gen.get_nonempty_type(result.err.as_ref()) {
                     let err_result = &err_results[0];
-                    format!("{result_tmp}.val.err = {err_result};")
+                    format!("{result_tmp}.val.err = {err_result};\n")
                 } else {
                     String::new()
                 };
 
                 let ty = self.gen.type_string(&Type::Id(*ty));
                 uwriteln!(self.src, "{ty} {result_tmp};");
                 let op0 = &operands[0];
-                uwrite!(
+                uwriteln!(
                     self.src,
                     "switch ({op0}) {{
                         case 0: {{
                             {result_tmp}.is_err = false;
-                            {ok}
-                            {set_ok}
+                            {ok}\
+                            {set_ok}\
                             break;
                         }}
                         case 1: {{
                             {result_tmp}.is_err = true;
-                            {err}
-                            {set_err}
+                            {err}\
+                            {set_err}\
                             break;
                         }}
                     }}"
@@ -2384,6 +2397,15 @@ fn int_repr(ty: Int) -> &'static str {
     }
 }
 
+fn int_max_str(ty: Int) -> String {
+    match ty {
+        Int::U8 => u8::MAX.to_string(),
+        Int::U16 => u16::MAX.to_string(),
+        Int::U32 => u32::MAX.to_string(),
+        Int::U64 => u64::MAX.to_string(),
+    }
+}
+
 fn flags_repr(f: &Flags) -> Int {
     match f.repr() {
         FlagsRepr::U8 => Int::U8,

tests/runtime/flavorful/host.rs

@@ -4,7 +4,9 @@ use wit_bindgen_host_wasmtime_rust::Result as HostResult;
 wit_bindgen_host_wasmtime_rust::generate!("../../tests/runtime/flavorful/world.wit");
 
 #[derive(Default)]
-pub struct MyImports;
+pub struct MyImports {
+    errored: bool
+}
 
 impl imports::Imports for MyImports {
     fn f_list_in_record1(&mut self, ty: imports::ListInRecord1) -> Result<()> {
@@ -57,10 +59,14 @@ impl imports::Imports for MyImports {
     }
 
     fn errno_result(&mut self) -> HostResult<(), imports::MyErrno> {
+        if self.errored {
+            return Ok(());
+        }
         imports::MyErrno::A.to_string();
         format!("{:?}", imports::MyErrno::A);
         fn assert_error<T: std::error::Error>() {}
         assert_error::<imports::MyErrno>();
+        self.errored = true;
         Err(imports::MyErrno::B)?
     }
 

tests/runtime/flavorful/host.ts

@@ -24,8 +24,12 @@ export function fListInVariant3(x: any) {
   assert.strictEqual(x, 'input3');
   return 'output3';
 }
+let firstErr = true;
 export function errnoResult() {
-  throw new Error('b');
+  if (firstErr) {
+    firstErr = false;
+    throw new Error('b');
+  }
 }
 export function listTypedefs(x: any, y: any) {
   assert.strictEqual(x, 'typedef1');

tests/runtime/flavorful/wasm.c

@@ -63,6 +63,8 @@ void flavorful_test_imports() {
 
   assert(imports_errno_result() == IMPORTS_MY_ERRNO_B);
 
+  assert(imports_errno_result() == IMPORTS_RESULT_MY_ERRNO_OK);
+
   {
     flavorful_string_t a;
     flavorful_string_set(&a, "typedef1");

tests/runtime/flavorful/wasm.rs

@@ -43,6 +43,8 @@ impl Flavorful for Component {
         fn assert_error<T: std::error::Error>() {}
         assert_error::<MyErrno>();
 
+        assert!(errno_result().is_ok());
+
         let (a, b) = list_typedefs("typedef1", &["typedef2"]);
         assert_eq!(a, b"typedef3");
         assert_eq!(b.len(), 1);