Add anyref downcast methods to the C and C++ APIs (#12917)

Author: fitzgen

crates/c-api/include/wasmtime/gc.h

@@ -535,6 +535,60 @@ WASM_API_EXTERN bool wasmtime_eqref_as_array(wasmtime_context_t *context,
                                              const wasmtime_eqref_t *eqref,
                                              wasmtime_arrayref_t *out);
 
+/**
+ * \brief Test whether an `anyref` is an `eqref`.
+ *
+ * Returns `false` for null references.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_is_eqref(wasmtime_context_t *context,
+                                              const wasmtime_anyref_t *anyref);
+
+/**
+ * \brief Downcast an `anyref` to an `eqref`.
+ *
+ * If the given `anyref` is an `eqref`, a new root is stored in `out` and
+ * `true` is returned. Otherwise `false` is returned and `out` is set to null.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_as_eqref(wasmtime_context_t *context,
+                                              const wasmtime_anyref_t *anyref,
+                                              wasmtime_eqref_t *out);
+
+/**
+ * \brief Test whether an `anyref` is a `structref`.
+ *
+ * Returns `false` for null references.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_is_struct(wasmtime_context_t *context,
+                                               const wasmtime_anyref_t *anyref);
+
+/**
+ * \brief Downcast an `anyref` to a `structref`.
+ *
+ * If the given `anyref` is a `structref`, a new root is stored in `out` and
+ * `true` is returned. Otherwise `false` is returned and `out` is set to null.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_as_struct(wasmtime_context_t *context,
+                                               const wasmtime_anyref_t *anyref,
+                                               wasmtime_structref_t *out);
+
+/**
+ * \brief Test whether an `anyref` is an `arrayref`.
+ *
+ * Returns `false` for null references.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_is_array(wasmtime_context_t *context,
+                                              const wasmtime_anyref_t *anyref);
+
+/**
+ * \brief Downcast an `anyref` to an `arrayref`.
+ *
+ * If the given `anyref` is an `arrayref`, a new root is stored in `out` and
+ * `true` is returned. Otherwise `false` is returned and `out` is set to null.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_as_array(wasmtime_context_t *context,
+                                              const wasmtime_anyref_t *anyref,
+                                              wasmtime_arrayref_t *out);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

crates/c-api/include/wasmtime/gc.hh

@@ -445,6 +445,35 @@ inline ArrayRef EqRef::as_array(Store::Context cx) const {
   return ArrayRef(out);
 }
 
+// AnyRef downcast method definitions (declared in val.hh)
+inline bool AnyRef::is_eqref(Store::Context cx) const {
+  return wasmtime_anyref_is_eqref(cx.capi(), &val);
+}
+inline bool AnyRef::is_struct(Store::Context cx) const {
+  return wasmtime_anyref_is_struct(cx.capi(), &val);
+}
+inline bool AnyRef::is_array(Store::Context cx) const {
+  return wasmtime_anyref_is_array(cx.capi(), &val);
+}
+inline std::optional<EqRef> AnyRef::as_eqref(Store::Context cx) const {
+  wasmtime_eqref_t out;
+  if (wasmtime_anyref_as_eqref(cx.capi(), &val, &out))
+    return EqRef(out);
+  return std::nullopt;
+}
+inline std::optional<StructRef> AnyRef::as_struct(Store::Context cx) const {
+  wasmtime_structref_t out;
+  if (wasmtime_anyref_as_struct(cx.capi(), &val, &out))
+    return StructRef(out);
+  return std::nullopt;
+}
+inline std::optional<ArrayRef> AnyRef::as_array(Store::Context cx) const {
+  wasmtime_arrayref_t out;
+  if (wasmtime_anyref_as_array(cx.capi(), &val, &out))
+    return ArrayRef(out);
+  return std::nullopt;
+}
+
 } // namespace wasmtime
 
 #endif // WASMTIME_GC_HH

crates/c-api/include/wasmtime/val.hh

@@ -13,6 +13,10 @@
 
 namespace wasmtime {
 
+class EqRef;
+class StructRef;
+class ArrayRef;
+
 /**
  * \brief Representation of a WebAssembly `externref` value.
  *
@@ -181,6 +185,24 @@ public:
   bool is_i31(Store::Context cx) const {
     return wasmtime_anyref_is_i31(cx.ptr, &val);
   }
+
+  /// \brief Returns `true` if this anyref is an eqref.
+  inline bool is_eqref(Store::Context cx) const;
+
+  /// \brief Returns `true` if this anyref is a structref.
+  inline bool is_struct(Store::Context cx) const;
+
+  /// \brief Returns `true` if this anyref is an arrayref.
+  inline bool is_array(Store::Context cx) const;
+
+  /// \brief Downcast to eqref. Returns null eqref if not an eqref.
+  inline std::optional<EqRef> as_eqref(Store::Context cx) const;
+
+  /// \brief Downcast to structref. Returns null structref if not a structref.
+  inline std::optional<StructRef> as_struct(Store::Context cx) const;
+
+  /// \brief Downcast to arrayref. Returns null arrayref if not an arrayref.
+  inline std::optional<ArrayRef> as_array(Store::Context cx) const;
 };
 
 /// \brief Container for the `v128` WebAssembly type.

crates/c-api/src/ref.rs

@@ -937,3 +937,93 @@ pub unsafe extern "C" fn wasmtime_eqref_as_array(
     crate::initialize(out, None::<OwnedRooted<ArrayRef>>.into());
     false
 }
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_anyref_is_eqref(
+    cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+) -> bool {
+    match anyref.and_then(|a| a.as_wasmtime()) {
+        Some(anyref) => anyref.is_eqref(&cx).expect("OwnedRooted always in scope"),
+        None => false,
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_anyref_as_eqref(
+    mut cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+    out: &mut MaybeUninit<wasmtime_eqref_t>,
+) -> bool {
+    if let Some(anyref) = anyref.and_then(|a| a.as_wasmtime()) {
+        let mut scope = RootScope::new(&mut cx);
+        let rooted = anyref.to_rooted(&mut scope);
+        if let Ok(Some(eqref)) = rooted.as_eqref(&mut scope) {
+            let owned = eqref.to_owned_rooted(&mut scope).expect("in scope");
+            crate::initialize(out, Some(owned).into());
+            return true;
+        }
+    }
+    crate::initialize(out, None::<OwnedRooted<EqRef>>.into());
+    false
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_anyref_is_struct(
+    cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+) -> bool {
+    match anyref.and_then(|a| a.as_wasmtime()) {
+        Some(anyref) => anyref.is_struct(&cx).expect("OwnedRooted always in scope"),
+        None => false,
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_anyref_as_struct(
+    mut cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+    out: &mut MaybeUninit<wasmtime_structref_t>,
+) -> bool {
+    if let Some(anyref) = anyref.and_then(|a| a.as_wasmtime()) {
+        let mut scope = RootScope::new(&mut cx);
+        let rooted = anyref.to_rooted(&mut scope);
+        if let Ok(Some(structref)) = rooted.as_struct(&scope) {
+            let owned = structref.to_owned_rooted(&mut scope).expect("in scope");
+            crate::initialize(out, Some(owned).into());
+            return true;
+        }
+    }
+    crate::initialize(out, None::<OwnedRooted<StructRef>>.into());
+    false
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_anyref_is_array(
+    cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+) -> bool {
+    match anyref.and_then(|a| a.as_wasmtime()) {
+        Some(anyref) => anyref.is_array(&cx).expect("OwnedRooted always in scope"),
+        None => false,
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn wasmtime_anyref_as_array(
+    mut cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+    out: &mut MaybeUninit<wasmtime_arrayref_t>,
+) -> bool {
+    if let Some(anyref) = anyref.and_then(|a| a.as_wasmtime()) {
+        let mut scope = RootScope::new(&mut cx);
+        let rooted = anyref.to_rooted(&mut scope);
+        if let Ok(Some(arrayref)) = rooted.as_array(&scope) {
+            let owned = arrayref.to_owned_rooted(&mut scope).expect("in scope");
+            crate::initialize(out, Some(owned).into());
+            return true;
+        }
+    }
+    crate::initialize(out, None::<OwnedRooted<ArrayRef>>.into());
+    false
+}

crates/c-api/tests/gc.cc

@@ -232,3 +232,82 @@ TEST(ArrayRef, UpcastAndDowncast) {
   AnyRef any = arr.to_anyref();
   EXPECT_FALSE(any.is_i31(cx));
 }
+
+TEST(AnyRef, DowncastI31) {
+  Config config;
+  config.wasm_gc(true);
+  Engine engine(std::move(config));
+  Store store(engine);
+  auto cx = store.context();
+
+  AnyRef any = AnyRef::i31(cx, 42);
+  EXPECT_TRUE(any.is_i31(cx));
+  EXPECT_TRUE(any.is_eqref(cx));
+  EXPECT_FALSE(any.is_struct(cx));
+  EXPECT_FALSE(any.is_array(cx));
+
+  // Downcast to eqref.
+  auto opt_eq = any.as_eqref(cx);
+  EXPECT_TRUE(opt_eq);
+  EqRef eq = *opt_eq;
+  EXPECT_TRUE(eq.is_i31(cx));
+  auto val = eq.i31_get_u(cx);
+  ASSERT_TRUE(val.has_value());
+  EXPECT_EQ(*val, 42u);
+}
+
+TEST(AnyRef, DowncastStruct) {
+  Config config;
+  config.wasm_gc(true);
+  Engine engine(std::move(config));
+  Store store(engine);
+  auto cx = store.context();
+
+  auto ty = StructType::create(engine, {FieldType::const_(WASMTIME_I32)});
+  auto pre = StructRefPre::create(cx, ty);
+  auto result = StructRef::create(cx, pre, {Val(int32_t(77))});
+  ASSERT_TRUE(result);
+  StructRef s = result.ok();
+
+  AnyRef any = s.to_anyref();
+  EXPECT_TRUE(any.is_eqref(cx));
+  EXPECT_TRUE(any.is_struct(cx));
+  EXPECT_FALSE(any.is_array(cx));
+  EXPECT_FALSE(any.is_i31(cx));
+
+  // Downcast back to struct.
+  auto opt_s2 = any.as_struct(cx);
+  EXPECT_TRUE(opt_s2);
+  StructRef s2 = *opt_s2;
+  auto v = s2.field(cx, 0);
+  ASSERT_TRUE(v);
+  EXPECT_EQ(v.ok().i32(), 77);
+}
+
+TEST(AnyRef, DowncastArray) {
+  Config config;
+  config.wasm_gc(true);
+  Engine engine(std::move(config));
+  Store store(engine);
+  auto cx = store.context();
+
+  auto ty = ArrayType::create(engine, FieldType::const_(WASMTIME_I32));
+  auto pre = ArrayRefPre::create(cx, ty);
+  auto result = ArrayRef::create(cx, pre, Val(int32_t(55)), 2);
+  ASSERT_TRUE(result);
+  ArrayRef arr = result.ok();
+
+  AnyRef any = arr.to_anyref();
+  EXPECT_TRUE(any.is_eqref(cx));
+  EXPECT_FALSE(any.is_struct(cx));
+  EXPECT_TRUE(any.is_array(cx));
+  EXPECT_FALSE(any.is_i31(cx));
+
+  // Downcast back to array.
+  auto opt_arr2 = any.as_array(cx);
+  EXPECT_TRUE(opt_arr2);
+  ArrayRef arr2 = *opt_arr2;
+  auto len = arr2.len(cx);
+  ASSERT_TRUE(len);
+  EXPECT_EQ(len.ok(), 2u);
+}