Remove the explicit gc feature from the wasmtime dependency in the c-api crate

tolumide-ng · tolumide-ng · commit 0f78a8614e67 · 2026-04-06T21:01:52.000+02:00
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -414,6 +414,7 @@ jobs:
               -p wasmtime-c-api --no-default-features
               -p wasmtime-c-api --no-default-features --features wat
               -p wasmtime-c-api --no-default-features --features wasi
+              -p wasmtime-c-api --no-default-features --features gc
 
           - name: wasmtime-wasi-http
             checks: |
diff --git a/crates/c-api-macros/src/lib.rs b/crates/c-api-macros/src/lib.rs
@@ -135,13 +135,15 @@ pub fn declare_ref(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
         #[doc = #as_ref_docs]
         #[unsafe(no_mangle)]
+        #[cfg(feature = "gc")]
         pub extern fn #as_ref(a: &#ty) -> Box<crate::wasm_ref_t> {
             eprintln!("`{}` is not implemented", stringify!(#as_ref));
             std::process::abort();
         }
 
         #[doc = #as_ref_const_docs]
         #[unsafe(no_mangle)]
+        #[cfg(feature = "gc")]
         pub extern fn #as_ref_const(a: &#ty) -> Box<crate::wasm_ref_t> {
             eprintln!("`{}` is not implemented", stringify!(#as_ref_const));
             std::process::abort();
diff --git a/crates/c-api/Cargo.toml b/crates/c-api/Cargo.toml
@@ -21,7 +21,7 @@ doctest = false
 
 [dependencies]
 env_logger = { workspace = true, optional = true }
-wasmtime = { workspace = true, features = ['runtime', 'gc', 'std'] }
+wasmtime = { workspace = true, features = ['runtime', 'std'] }
 wasmtime-c-api-macros = { workspace = true }
 log = { workspace = true }
 tracing = { workspace = true }
diff --git a/crates/c-api/include/wasmtime/config.hh b/crates/c-api/include/wasmtime/config.hh
@@ -303,13 +303,15 @@ class Config {
     wasmtime_config_wasm_tail_call_set(ptr.get(), enable);
   }
 
+  #ifdef WASMTIME_FEATURE_GC
   /// \brief Configures whether the WebAssembly reference types proposal is
   /// enabled
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_reference_types
   void wasm_reference_types(bool enable) {
     wasmtime_config_wasm_reference_types_set(ptr.get(), enable);
   }
+  #endif // WASMTIME_FEATURE_GC
 
   /// \brief Configures whether the WebAssembly simd proposal is enabled
   ///
@@ -361,11 +363,13 @@ class Config {
     wasmtime_config_wasm_memory64_set(ptr.get(), enable);
   }
 
+  #ifdef WASMTIME_FEATURE_GC
   /// \brief Configures whether the WebAssembly Garbage Collection proposal will
   /// be enabled
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_gc
   void wasm_gc(bool enable) { wasmtime_config_wasm_gc_set(ptr.get(), enable); }
+  #endif // WASMTIME_FEATURE_GC
 
   /// \brief Configures whether the WebAssembly function references proposal
   /// will be enabled
@@ -383,13 +387,15 @@ class Config {
     wasmtime_config_wasm_wide_arithmetic_set(ptr.get(), enable);
   }
 
+  #ifdef WASMTIME_FEATURE_GC
   /// \brief Configures whether the WebAssembly exceptions proposal will be
   /// enabled
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_exceptions
   void wasm_exceptions(bool enable) {
     wasmtime_config_wasm_exceptions_set(ptr.get(), enable);
   }
+  #endif // WASMTIME_FEATURE_GC
 
   /// \brief Configures whether the WebAssembly custom-page-sizes proposal will
   /// be enabled
diff --git a/crates/c-api/include/wasmtime/func.hh b/crates/c-api/include/wasmtime/func.hh
@@ -81,6 +81,7 @@ NATIVE_WASM_TYPE(double, F64, f64)
 
 #undef NATIVE_WASM_TYPE
 
+#ifdef WASMTIME_FEATURE_GC
 /// Type information for `externref`, represented on the host as an optional
 /// `ExternRef`.
 template <> struct WasmType<std::optional<ExternRef>> {
@@ -102,8 +103,9 @@ template <> struct WasmType<std::optional<ExternRef>> {
       p->externref = 0;
     }
   }
+  
   static std::optional<ExternRef> load(Store::Context cx,
-                                       wasmtime_val_raw_t *p) {
+                                      wasmtime_val_raw_t *p) {
     if (p->externref == 0) {
       return std::nullopt;
     }
@@ -112,6 +114,7 @@ template <> struct WasmType<std::optional<ExternRef>> {
     return ExternRef(val);
   }
 };
+#endif // WASMTIME_FEATURE_GC
 
 /// Type information for the `V128` host value used as a wasm value.
 template <> struct WasmType<V128> {
diff --git a/crates/c-api/include/wasmtime/store.h b/crates/c-api/include/wasmtime/store.h
@@ -144,8 +144,10 @@ WASM_API_EXTERN void wasmtime_context_set_data(wasmtime_context_t *context,
  *
  * The `context` argument must not be NULL.
  */
+#ifdef WASMTIME_FEATURE_GC
 WASM_API_EXTERN wasmtime_error_t *
 wasmtime_context_gc(wasmtime_context_t *context);
+#endif
 
 /**
  * \brief Set fuel to this context's store for wasm to consume while executing.
diff --git a/crates/c-api/include/wasmtime/store.hh b/crates/c-api/include/wasmtime/store.hh
@@ -94,6 +94,7 @@ public:
     /// Creates a context referencing the provided `Caller`.
     Context(Caller *caller);
 
+#ifdef WASMTIME_FEATURE_GC
     /// Runs a garbage collection pass in the referenced store to collect loose
     /// `externref` values, if any are available.
     Result<std::monostate> gc() {
@@ -103,6 +104,7 @@ public:
       }
       return std::monostate();
     }
+#endif
 
     /// Injects fuel to be consumed within this store.
     ///
@@ -253,9 +255,11 @@ public:
   /// Explicit function to acquire a `Context` from this store.
   Context context() { return this; }
 
+#ifdef WASMTIME_FEATURE_GC
   /// Runs a garbage collection pass in the referenced store to collect loose
   /// GC-managed objects, if any are available.
   Result<std::monostate> gc() { return context().gc(); }
+#endif
 
 private:
   template <typename F>
diff --git a/crates/c-api/include/wasmtime/val.h b/crates/c-api/include/wasmtime/val.h
@@ -56,6 +56,7 @@ typedef struct wasmtime_anyref {
   void *__private3;
 } wasmtime_anyref_t;
 
+#ifdef WASMTIME_FEATURE_GC
 /// \brief Helper function to initialize the `ref` provided to a null anyref
 /// value.
 static inline void wasmtime_anyref_set_null(wasmtime_anyref_t *ref) {
@@ -71,6 +72,7 @@ static inline bool wasmtime_anyref_is_null(const wasmtime_anyref_t *ref) {
   return ref->store_id == 0;
 }
 
+
 /**
  * \brief Creates a new reference pointing to the same data that `anyref`
  * points to (depending on the configured collector this might increase a
@@ -201,6 +203,8 @@ WASM_API_EXTERN bool wasmtime_anyref_i31_get_s(wasmtime_context_t *context,
  * `wasmtime_externref_set_null`. Null can be tested for with the
  * `wasmtime_externref_is_null` function.
  */
+#endif // WASMTIME_FEATURE_GC
+
 typedef struct wasmtime_externref {
   /// Internal metadata tracking within the store, embedders should not
   /// configure or modify these fields.
@@ -213,6 +217,7 @@ typedef struct wasmtime_externref {
   void *__private3;
 } wasmtime_externref_t;
 
+#ifdef WASMTIME_FEATURE_GC
 /// \brief Helper function to initialize the `ref` provided to a null externref
 /// value.
 static inline void wasmtime_externref_set_null(wasmtime_externref_t *ref) {
@@ -313,6 +318,7 @@ WASM_API_EXTERN void wasmtime_externref_from_raw(wasmtime_context_t *context,
  */
 WASM_API_EXTERN uint32_t wasmtime_externref_to_raw(
     wasmtime_context_t *context, const wasmtime_externref_t *ref);
+#endif // WASMTIME_FEATURE_GC
 
 /**
  * \typedef wasmtime_exnref_t
@@ -397,6 +403,7 @@ typedef uint8_t wasmtime_valkind_t;
 /// stored in little-endian order.
 typedef uint8_t wasmtime_v128[16];
 
+
 /**
  * \typedef wasmtime_valunion_t
  * \brief Convenience alias for #wasmtime_valunion
diff --git a/crates/c-api/include/wasmtime/val.hh b/crates/c-api/include/wasmtime/val.hh
@@ -17,6 +17,7 @@ class EqRef;
 class StructRef;
 class ArrayRef;
 
+#ifdef WASMTIME_FEATURE_GC
 /**
  * \brief Representation of a WebAssembly `externref` value.
  *
@@ -103,9 +104,12 @@ public:
     return wasmtime_externref_to_raw(cx.capi(), &val);
   }
 };
+#endif // WASMTIME_FEATURE_GC
 
 class EqRef;
 
+
+#ifdef WASMTIME_FEATURE_GC
 /**
  * \brief Representation of a WebAssembly `anyref` value.
  */
@@ -204,6 +208,7 @@ public:
   /// \brief Downcast to arrayref. Returns null arrayref if not an arrayref.
   inline std::optional<ArrayRef> as_array(Store::Context cx) const;
 };
+#endif // WASMTIME_FEATURE_GC
 
 /// \brief Container for the `v128` WebAssembly type.
 struct V128 {
diff --git a/crates/c-api/src/config.rs b/crates/c-api/src/config.rs
@@ -90,11 +90,13 @@ pub extern "C" fn wasmtime_config_wasm_tail_call_set(c: &mut wasm_config_t, enab
 }
 
 #[unsafe(no_mangle)]
+#[cfg(feature = "gc")]
 pub extern "C" fn wasmtime_config_wasm_reference_types_set(c: &mut wasm_config_t, enable: bool) {
     c.config.wasm_reference_types(enable);
 }
 
 #[unsafe(no_mangle)]
+#[cfg(feature = "gc")]
 pub extern "C" fn wasmtime_config_wasm_function_references_set(
     c: &mut wasm_config_t,
     enable: bool,
@@ -103,6 +105,7 @@ pub extern "C" fn wasmtime_config_wasm_function_references_set(
 }
 
 #[unsafe(no_mangle)]
+#[cfg(feature = "gc")]
 pub extern "C" fn wasmtime_config_wasm_gc_set(c: &mut wasm_config_t, enable: bool) {
     c.config.wasm_gc(enable);
 }
@@ -476,6 +479,7 @@ pub extern "C" fn wasmtime_config_wasm_wide_arithmetic_set(c: &mut wasm_config_t
 }
 
 #[unsafe(no_mangle)]
+#[cfg(feature = "gc")]
 pub extern "C" fn wasmtime_config_wasm_exceptions_set(c: &mut wasm_config_t, enable: bool) {
     c.config.wasm_exceptions(enable);
 }
diff --git a/crates/c-api/src/func.rs b/crates/c-api/src/func.rs
@@ -10,9 +10,11 @@ use std::mem::{self, MaybeUninit};
 use std::panic::{self, AssertUnwindSafe};
 use std::ptr;
 use std::str;
+#[cfg(feature = "gc")]
+use wasmtime::RootScope;
 use wasmtime::{
-    AsContext, AsContextMut, Error, Extern, Func, Result, RootScope, StoreContext, StoreContextMut,
-    Trap, Val, ValRaw,
+    AsContext, AsContextMut, Error, Extern, Func, Result, StoreContext, StoreContextMut, Trap, Val,
+    ValRaw,
 };
 
 #[derive(Clone)]
@@ -351,13 +353,15 @@ pub unsafe extern "C" fn wasmtime_func_call(
     nresults: usize,
     trap_ret: &mut *mut wasm_trap_t,
 ) -> Option<Box<wasmtime_error_t>> {
-    let mut scope = RootScope::new(&mut store);
-    let mut params = mem::take(&mut scope.as_context_mut().data_mut().wasm_val_storage);
+    #[cfg(feature = "gc")]
+    let mut store = RootScope::new(&mut store);
+    let mut params = mem::take(&mut store.as_context_mut().data_mut().wasm_val_storage);
+
     let (wt_params, wt_results) = translate_args(
         &mut params,
         crate::slice_from_raw_parts(args, nargs)
             .iter()
-            .map(|i| i.to_val(&mut scope)),
+            .map(|i| i.to_val(&mut store)),
         nresults,
     );
 
@@ -366,16 +370,16 @@ pub unsafe extern "C" fn wasmtime_func_call(
     // can. As a result we catch panics here and transform them to traps to
     // allow the caller to have any insulation possible against Rust panics.
     let result = panic::catch_unwind(AssertUnwindSafe(|| {
-        func.call(&mut scope, wt_params, wt_results)
+        func.call(&mut store, wt_params, wt_results)
     }));
     match result {
         Ok(Ok(())) => {
             let results = crate::slice_from_raw_parts_mut(results, nresults);
             for (slot, val) in results.iter_mut().zip(wt_results.iter()) {
-                crate::initialize(slot, wasmtime_val_t::from_val(&mut scope, *val));
+                crate::initialize(slot, wasmtime_val_t::from_val(&mut store, *val));
             }
             params.truncate(0);
-            scope.as_context_mut().data_mut().wasm_val_storage = params;
+            store.as_context_mut().data_mut().wasm_val_storage = params;
             None
         }
         Ok(Err(trap)) => store_err(trap, trap_ret),
diff --git a/crates/c-api/src/global.rs b/crates/c-api/src/global.rs
@@ -3,7 +3,9 @@ use crate::{
     wasm_store_t, wasm_val_t, wasmtime_error_t, wasmtime_val_t,
 };
 use std::mem::MaybeUninit;
-use wasmtime::{Extern, Global, RootScope};
+#[cfg(feature = "gc")]
+use wasmtime::RootScope;
+use wasmtime::{Extern, Global};
 
 #[derive(Clone)]
 #[repr(transparent)]
@@ -84,9 +86,11 @@ pub unsafe extern "C" fn wasmtime_global_new(
     val: &wasmtime_val_t,
     ret: &mut Global,
 ) -> Option<Box<wasmtime_error_t>> {
-    let mut scope = RootScope::new(&mut store);
-    let val = val.to_val(&mut scope);
-    let global = Global::new(scope, gt.ty().ty.clone(), val);
+    #[cfg(feature = "gc")]
+    let mut store = RootScope::new(&mut store);
+
+    let val = val.to_val(&mut store);
+    let global = Global::new(&mut store, gt.ty().ty.clone(), val);
     handle_result(global, |global| {
         *ret = global;
     })
@@ -106,9 +110,13 @@ pub extern "C" fn wasmtime_global_get(
     global: &Global,
     val: &mut MaybeUninit<wasmtime_val_t>,
 ) {
-    let mut scope = RootScope::new(store);
-    let gval = global.get(&mut scope);
-    crate::initialize(val, wasmtime_val_t::from_val(&mut scope, gval))
+    let mut store = store;
+
+    #[cfg(feature = "gc")]
+    let mut store = RootScope::new(&mut store);
+
+    let gval = global.get(&mut store);
+    crate::initialize(val, wasmtime_val_t::from_val(&mut store, gval))
 }
 
 #[unsafe(no_mangle)]
@@ -117,7 +125,9 @@ pub unsafe extern "C" fn wasmtime_global_set(
     global: &Global,
     val: &wasmtime_val_t,
 ) -> Option<Box<wasmtime_error_t>> {
-    let mut scope = RootScope::new(&mut store);
-    let val = val.to_val(&mut scope);
-    handle_result(global.set(scope, val), |()| {})
+    #[cfg(feature = "gc")]
+    let mut store = RootScope::new(&mut store);
+
+    let val = val.to_val(&mut store);
+    handle_result(global.set(&mut store, val), |()| {})
 }
diff --git a/crates/c-api/src/lib.rs b/crates/c-api/src/lib.rs
@@ -30,6 +30,7 @@ mod memory;
 mod module;
 #[cfg(feature = "profiling")]
 mod profiling;
+#[cfg(feature = "gc")]
 mod r#ref;
 mod sharedmemory;
 mod store;
@@ -51,6 +52,7 @@ pub use crate::instance::*;
 pub use crate::linker::*;
 pub use crate::memory::*;
 pub use crate::module::*;
+#[cfg(feature = "gc")]
 pub use crate::r#ref::*;
 pub use crate::store::*;
 pub use crate::table::*;
diff --git a/crates/c-api/src/ref.rs b/crates/c-api/src/ref.rs
@@ -1,4 +1,7 @@
-use crate::{WasmtimeStoreContextMut, abort};
+#![cfg(feature = "gc")]
+
+use crate::WasmtimeStoreContextMut;
+use crate::abort;
 use std::mem::{ManuallyDrop, MaybeUninit};
 use std::{num::NonZeroU64, os::raw::c_void, ptr};
 use wasmtime::{
@@ -423,7 +426,7 @@ pub unsafe extern "C" fn wasmtime_externref_data(
             let data = e.data(cx).ok()??;
             Some(data.downcast_ref::<crate::ForeignData>().unwrap().data)
         })
-        .unwrap_or(ptr::null_mut())
+        .unwrap_or(core::ptr::null_mut())
 }
 
 #[unsafe(no_mangle)]
diff --git a/crates/c-api/src/store.rs b/crates/c-api/src/store.rs
diff --git a/crates/c-api/src/table.rs b/crates/c-api/src/table.rs
diff --git a/crates/c-api/src/val.rs b/crates/c-api/src/val.rs

Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,7 @@ NATIVE_WASM_TYPE(double, F64, f64)`
`81`	`81`
`82`	`82`	`#undef NATIVE_WASM_TYPE`
`83`	`83`
	`84`	`+#ifdef WASMTIME_FEATURE_GC`
`84`	`85`	/// Type information for `externref`, represented on the host as an optional
`85`	`86`	/// `ExternRef`.
`86`	`87`	`template <> struct WasmType<std::optional<ExternRef>> {`
`@@ -102,8 +103,9 @@ template <> struct WasmType<std::optional<ExternRef>> {`
`102`	`103`	`p->externref = 0;`
`103`	`104`	`}`
`104`	`105`	`}`
	`106`	`+`
`105`	`107`	`static std::optional<ExternRef> load(Store::Context cx,`
`106`		`- wasmtime_val_raw_t *p) {`
	`108`	`+ wasmtime_val_raw_t *p) {`
`107`	`109`	`if (p->externref == 0) {`
`108`	`110`	`return std::nullopt;`
`109`	`111`	`}`
`@@ -112,6 +114,7 @@ template <> struct WasmType<std::optional<ExternRef>> {`
`112`	`114`	`return ExternRef(val);`
`113`	`115`	`}`
`114`	`116`	`};`
	`117`	`+#endif // WASMTIME_FEATURE_GC`
`115`	`118`
`116`	`119`	/// Type information for the `V128` host value used as a wasm value.
`117`	`120`	`template <> struct WasmType<V128> {`
Original file line number	Diff line number	Diff line change
`@@ -90,11 +90,13 @@ pub extern "C" fn wasmtime_config_wasm_tail_call_set(c: &mut wasm_config_t, enab`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`#[unsafe(no_mangle)]`
	`93`	`+#[cfg(feature = "gc")]`
`93`	`94`	`pub extern "C" fn wasmtime_config_wasm_reference_types_set(c: &mut wasm_config_t, enable: bool) {`
`94`	`95`	`c.config.wasm_reference_types(enable);`
`95`	`96`	`}`
`96`	`97`
`97`	`98`	`#[unsafe(no_mangle)]`
	`99`	`+#[cfg(feature = "gc")]`
`98`	`100`	`pub extern "C" fn wasmtime_config_wasm_function_references_set(`
`99`	`101`	`c: &mut wasm_config_t,`
`100`	`102`	`enable: bool,`
`@@ -103,6 +105,7 @@ pub extern "C" fn wasmtime_config_wasm_function_references_set(`
`103`	`105`	`}`
`104`	`106`
`105`	`107`	`#[unsafe(no_mangle)]`
	`108`	`+#[cfg(feature = "gc")]`
`106`	`109`	`pub extern "C" fn wasmtime_config_wasm_gc_set(c: &mut wasm_config_t, enable: bool) {`
`107`	`110`	`c.config.wasm_gc(enable);`
`108`	`111`	`}`
`@@ -476,6 +479,7 @@ pub extern "C" fn wasmtime_config_wasm_wide_arithmetic_set(c: &mut wasm_config_t`
`476`	`479`	`}`
`477`	`480`
`478`	`481`	`#[unsafe(no_mangle)]`
	`482`	`+#[cfg(feature = "gc")]`
`479`	`483`	`pub extern "C" fn wasmtime_config_wasm_exceptions_set(c: &mut wasm_config_t, enable: bool) {`
`480`	`484`	`c.config.wasm_exceptions(enable);`
`481`	`485`	`}`