c-api: component-model: Enum and option values (#10858)

* c-api: component-model: Enum values

* c-api: component-model: Option values

Author: MangoPeachGrape

crates/c-api/include/wasmtime/component/val.h

@@ -65,6 +65,12 @@ typedef uint8_t wasmtime_component_valkind_t;
 /// \brief Value of #wasmtime_component_valkind_t meaning that
 /// #wasmtime_component_val_t is a variant
 #define WASMTIME_COMPONENT_VARIANT 16
+/// \brief Value of #wasmtime_component_valkind_t meaning that
+/// #wasmtime_component_val_t is a enum
+#define WASMTIME_COMPONENT_ENUM 17
+/// \brief Value of #wasmtime_component_valkind_t meaning that
+/// #wasmtime_component_val_t is a option
+#define WASMTIME_COMPONENT_OPTION 18
 
 struct wasmtime_component_val;
 struct wasmtime_component_valrecord_entry;
@@ -144,6 +150,11 @@ typedef union {
   /// Field used if #wasmtime_component_val_t::kind is
   /// #WASMTIME_COMPONENT_VARIANT
   wasmtime_component_valvariant_t variant;
+  /// Field used if #wasmtime_component_val_t::kind is #WASMTIME_COMPONENT_ENUM
+  wasm_name_t enumeration;
+  /// Field used if #wasmtime_component_val_t::kind is
+  /// #WASMTIME_COMPONENT_OPTION
+  struct wasmtime_component_val *option;
 } wasmtime_component_valunion_t;
 
 /// \brief Represents possible runtime values which a component function can

crates/c-api/src/component/val.rs

@@ -166,6 +166,8 @@ pub enum wasmtime_component_val_t {
     Record(wasmtime_component_valrecord_t),
     Tuple(wasmtime_component_valtuple_t),
     Variant(wasmtime_component_valvariant_t),
+    Enum(wasm_name_t),
+    Option(Option<Box<Self>>),
 }
 
 impl Default for wasmtime_component_val_t {
@@ -199,6 +201,12 @@ impl From<&wasmtime_component_val_t> for Val {
                 let (a, b) = x.into();
                 Val::Variant(a, b)
             }
+            wasmtime_component_val_t::Enum(x) => {
+                Val::Enum(String::from_utf8(x.clone().take()).unwrap())
+            }
+            wasmtime_component_val_t::Option(x) => {
+                Val::Option(x.as_ref().map(|x| Box::new(Val::from(x.as_ref()))))
+            }
         }
     }
 }
@@ -225,8 +233,11 @@ impl From<&Val> for wasmtime_component_val_t {
             Val::Variant(discriminant, val) => {
                 wasmtime_component_val_t::Variant((discriminant, val).into())
             }
-            Val::Enum(_) => todo!(),
-            Val::Option(_val) => todo!(),
+            Val::Enum(x) => wasmtime_component_val_t::Enum(wasm_name_t::from_name(x.clone())),
+            Val::Option(x) => wasmtime_component_val_t::Option(
+                x.as_ref()
+                    .map(|x| Box::new(wasmtime_component_val_t::from(x.as_ref()))),
+            ),
             Val::Result(_val) => todo!(),
             Val::Flags(_items) => todo!(),
             Val::Resource(_resource_any) => todo!(),

crates/c-api/tests/component/values.cc

@@ -5,6 +5,7 @@
 
 #include <array>
 #include <format>
+#include <optional>
 #include <span>
 #include <variant>
 
@@ -546,6 +547,144 @@ local.get $res
   destroy(ctx);
 }
 
+TEST(component, value_enum) {
+  static const auto check = [](const wasmtime_component_val_t &val,
+                               std::string_view text) {
+    EXPECT_EQ(val.kind, WASMTIME_COMPONENT_ENUM);
+    EXPECT_EQ(
+        (std::string_view{val.of.enumeration.data, val.of.enumeration.size}),
+        text);
+  };
+
+  static const auto make =
+      [](std::string_view text) -> wasmtime_component_val_t {
+    auto ret = wasmtime_component_val_t{
+        .kind = WASMTIME_COMPONENT_ENUM,
+    };
+
+    wasm_name_new(&ret.of.enumeration, text.size(), text.data());
+
+    return ret;
+  };
+
+  auto ctx = create(
+      R"((enum "aa" "bb"))", R"(
+(param $x i32)
+(result i32)
+local.get $x
+call $do
+	  )",
+      "(param i32) (result i32)",
+      +[](void *, wasmtime_context_t *, const wasmtime_component_val_t *args,
+          size_t args_len, wasmtime_component_val_t *rets,
+          size_t rets_len) -> wasmtime_error_t * {
+        EXPECT_EQ(args_len, 1);
+        check(args[0], "aa");
+
+        EXPECT_EQ(rets_len, 1);
+        rets[0] = make("bb");
+
+        return nullptr;
+      });
+
+  auto arg = make("aa");
+  auto res = wasmtime_component_val_t{};
+
+  auto err =
+      wasmtime_component_func_call(&ctx.func, ctx.context, &arg, 1, &res, 1);
+  CHECK_ERR(err);
+
+  err = wasmtime_component_func_post_return(&ctx.func, ctx.context);
+  CHECK_ERR(err);
+
+  check(res, "bb");
+
+  wasmtime_component_val_delete(&arg);
+  wasmtime_component_val_delete(&res);
+
+  destroy(ctx);
+}
+
+TEST(component, value_option) {
+  static const auto check = [](const wasmtime_component_val_t &val,
+                               std::optional<uint32_t> value) {
+    EXPECT_EQ(val.kind, WASMTIME_COMPONENT_OPTION);
+
+    if (value.has_value()) {
+      EXPECT_NE(val.of.option, nullptr);
+      EXPECT_EQ(val.of.option->kind, WASMTIME_COMPONENT_U32);
+      EXPECT_EQ(val.of.option->of.u32, *value);
+    } else {
+      EXPECT_EQ(val.of.option, nullptr);
+    }
+  };
+
+  static const auto make =
+      [](std::optional<uint32_t> value) -> wasmtime_component_val_t {
+    auto ret = wasmtime_component_val_t{
+        .kind = WASMTIME_COMPONENT_OPTION,
+        .of = {.option = nullptr},
+    };
+
+    if (value.has_value()) {
+      ret.of.option = wasmtime_component_val_new();
+      *ret.of.option = wasmtime_component_val_t{
+          .kind = WASMTIME_COMPONENT_U32,
+          .of = {.u32 = *value},
+      };
+    }
+
+    return ret;
+  };
+
+  auto ctx = create(
+      R"((option u32))", R"(
+(param $x i32)
+(param $y i32)
+(result i32)
+(local $res i32)
+local.get $x
+local.get $y
+(call $realloc
+	(i32.const 0)
+	(i32.const 0)
+	(i32.const 4)
+	(i32.const 8))
+local.tee $res
+call $do
+local.get $res
+	  )",
+      "(param i32 i32 i32)",
+      +[](void *, wasmtime_context_t *, const wasmtime_component_val_t *args,
+          size_t args_len, wasmtime_component_val_t *rets,
+          size_t rets_len) -> wasmtime_error_t * {
+        EXPECT_EQ(args_len, 1);
+        check(args[0], 123);
+
+        EXPECT_EQ(rets_len, 1);
+        rets[0] = make({});
+
+        return nullptr;
+      });
+
+  auto arg = make(123);
+  auto res = wasmtime_component_val_t{};
+
+  auto err =
+      wasmtime_component_func_call(&ctx.func, ctx.context, &arg, 1, &res, 1);
+  CHECK_ERR(err);
+
+  err = wasmtime_component_func_post_return(&ctx.func, ctx.context);
+  CHECK_ERR(err);
+
+  check(res, {});
+
+  wasmtime_component_val_delete(&arg);
+  wasmtime_component_val_delete(&res);
+
+  destroy(ctx);
+}
+
 TEST(component, value_list_inner) {
   {
     auto x = wasmtime_component_val_t{