Enable warnings if gc is disabled (bytecodealliance#10149)

* Enable warnings if `gc` is disabled

Continuation of work in bytecodealliance#10131. This additionally handles turning off
`gc-null` and `gc-drc` and the various combinations within.

* Fix some more warnings

* Fix a feature combo build

Author: alexcrichton

crates/wasmtime/src/config.rs

@@ -2729,6 +2729,7 @@ impl Default for Collector {
     }
 }
 
+#[cfg(feature = "gc")]
 impl Collector {
     fn not_auto(&self) -> Option<Collector> {
         match self {

crates/wasmtime/src/lib.rs

@@ -285,9 +285,6 @@
 // here to get warnings in all configurations of Wasmtime.
 #![cfg_attr(
     any(
-        not(feature = "gc"),
-        not(feature = "gc-drc"),
-        not(feature = "gc-null"),
         not(feature = "cranelift"),
         not(feature = "runtime"),
         not(feature = "std"),

crates/wasmtime/src/runtime/externals/global.rs

@@ -1,13 +1,11 @@
 use crate::prelude::*;
-use crate::runtime::vm::{GcRootsList, SendSyncPtr};
 use crate::{
     store::{AutoAssertNoGc, StoreData, StoreOpaque, Stored},
     trampoline::generate_global_export,
     AnyRef, AsContext, AsContextMut, ExternRef, Func, GlobalType, HeapType, Mutability, Ref,
     RootedGcRefImpl, Val, ValType,
 };
 use core::ptr;
-use core::ptr::NonNull;
 use wasmtime_environ::TypeTrace;
 
 /// A WebAssembly `global` value which can be read and written to.
@@ -216,17 +214,20 @@ impl Global {
         Ok(())
     }
 
-    pub(crate) fn trace_root(&self, store: &mut StoreOpaque, gc_roots_list: &mut GcRootsList) {
+    #[cfg(feature = "gc")]
+    pub(crate) fn trace_root(
+        &self,
+        store: &mut StoreOpaque,
+        gc_roots_list: &mut crate::runtime::vm::GcRootsList,
+    ) {
         if let Some(ref_ty) = self._ty(store).content().as_ref() {
             if !ref_ty.is_vmgcref_type_and_points_to_object() {
                 return;
             }
 
             if let Some(gc_ref) = unsafe { store[self.0].definition.as_ref().as_gc_ref() } {
-                let gc_ref = NonNull::from(gc_ref);
-                let gc_ref = SendSyncPtr::new(gc_ref);
                 unsafe {
-                    gc_roots_list.add_root(gc_ref, "Wasm global");
+                    gc_roots_list.add_root(gc_ref.into(), "Wasm global");
                 }
             }
         }

crates/wasmtime/src/runtime/externals/table.rs

@@ -5,8 +5,6 @@ use crate::trampoline::generate_table_export;
 use crate::vm::ExportTable;
 use crate::{AnyRef, AsContext, AsContextMut, ExternRef, Func, HeapType, Ref, TableType};
 use core::iter;
-use core::ptr::NonNull;
-use runtime::{GcRootsList, SendSyncPtr};
 use wasmtime_environ::TypeTrace;
 
 /// A WebAssembly `table`, or an array of values.
@@ -376,7 +374,12 @@ impl Table {
         Ok(())
     }
 
-    pub(crate) fn trace_roots(&self, store: &mut StoreOpaque, gc_roots_list: &mut GcRootsList) {
+    #[cfg(feature = "gc")]
+    pub(crate) fn trace_roots(
+        &self,
+        store: &mut StoreOpaque,
+        gc_roots_list: &mut crate::runtime::vm::GcRootsList,
+    ) {
         if !self
             ._ty(store)
             .element()
@@ -388,10 +391,8 @@ impl Table {
         let table = self.wasmtime_table(store, iter::empty());
         for gc_ref in unsafe { (*table).gc_refs_mut() } {
             if let Some(gc_ref) = gc_ref {
-                let gc_ref = NonNull::from(gc_ref);
-                let gc_ref = SendSyncPtr::new(gc_ref);
                 unsafe {
-                    gc_roots_list.add_root(gc_ref, "Wasm table element");
+                    gc_roots_list.add_root(gc_ref.into(), "Wasm table element");
                 }
             }
         }

crates/wasmtime/src/runtime/func.rs

@@ -13,7 +13,6 @@ use crate::{
 use alloc::sync::Arc;
 use core::ffi::c_void;
 use core::mem::{self, MaybeUninit};
-use core::num::NonZeroUsize;
 use core::ptr::NonNull;
 #[cfg(feature = "async")]
 use core::{future::Future, pin::Pin};
@@ -1211,7 +1210,7 @@ impl Func {
             // already. If it is at capacity (unlikely) then we need to do a GC
             // to free up space.
             let num_gc_refs = ty.as_wasm_func_type().non_i31_gc_ref_params_count();
-            if let Some(num_gc_refs) = NonZeroUsize::new(num_gc_refs) {
+            if let Some(num_gc_refs) = core::num::NonZeroUsize::new(num_gc_refs) {
                 return Ok(opaque
                     .gc_store()?
                     .gc_heap
@@ -2444,6 +2443,7 @@ impl HostFunc {
     }
 
     /// Analog of [`Func::wrap_inner`]
+    #[cfg(any(feature = "component-model", feature = "async"))]
     pub fn wrap_inner<F, T, Params, Results>(engine: &Engine, func: F) -> Self
     where
         F: Fn(Caller<'_, T>, Params) -> Results + Send + Sync + 'static,

crates/wasmtime/src/runtime/func/typed.rs

@@ -9,7 +9,6 @@ use crate::{
 use core::ffi::c_void;
 use core::marker;
 use core::mem::{self, MaybeUninit};
-use core::num::NonZeroUsize;
 use core::ptr::{self, NonNull};
 use wasmtime_environ::VMSharedTypeIndex;
 
@@ -155,7 +154,7 @@ where
         {
             // See the comment in `Func::call_impl_check_args`.
             let num_gc_refs = _params.vmgcref_pointing_to_object_count();
-            if let Some(num_gc_refs) = NonZeroUsize::new(num_gc_refs) {
+            if let Some(num_gc_refs) = core::num::NonZeroUsize::new(num_gc_refs) {
                 return _store
                     .unwrap_gc_store()
                     .gc_heap

crates/wasmtime/src/runtime/gc.rs

@@ -83,6 +83,7 @@ impl<T> fmt::Display for GcHeapOutOfMemory<T> {
 impl<T> core::error::Error for GcHeapOutOfMemory<T> {}
 
 impl<T> GcHeapOutOfMemory<T> {
+    #[cfg(feature = "gc")]
     pub(crate) fn new(inner: T) -> Self {
         Self { inner }
     }

crates/wasmtime/src/runtime/gc/disabled/arrayref.rs

@@ -1,7 +1,6 @@
-use crate::runtime::vm::VMGcRef;
 use crate::{
-    store::{AutoAssertNoGc, StoreContextMut, StoreOpaque},
-    ArrayType, AsContext, AsContextMut, GcRefImpl, Result, Rooted, Val, I31,
+    store::{StoreContextMut, StoreOpaque},
+    ArrayType, AsContext, AsContextMut, GcRefImpl, Result, Val,
 };
 
 /// Support for `ArrayRefPre` disabled at compile time because the `gc` cargo
@@ -15,13 +14,6 @@ pub enum ArrayRef {}
 impl GcRefImpl for ArrayRef {}
 
 impl ArrayRef {
-    pub(crate) fn from_cloned_gc_ref(
-        _store: &mut AutoAssertNoGc<'_>,
-        _gc_ref: VMGcRef,
-    ) -> Rooted<Self> {
-        unreachable!()
-    }
-
     pub fn ty(&self, _store: impl AsContext) -> Result<ArrayType> {
         match *self {}
     }

crates/wasmtime/src/runtime/gc/disabled/eqref.rs

@@ -1,7 +1,5 @@
-use crate::runtime::vm::VMGcRef;
 use crate::{
-    store::{AutoAssertNoGc, StoreOpaque},
-    ArrayRef, AsContext, AsContextMut, GcRefImpl, HeapType, ManuallyRooted, Result, Rooted,
+    store::StoreOpaque, ArrayRef, AsContext, GcRefImpl, HeapType, ManuallyRooted, Result, Rooted,
     StructRef, I31,
 };
 
@@ -40,13 +38,6 @@ impl From<ManuallyRooted<ArrayRef>> for ManuallyRooted<EqRef> {
 impl GcRefImpl for EqRef {}
 
 impl EqRef {
-    pub(crate) fn from_cloned_gc_ref(
-        _store: &mut AutoAssertNoGc<'_>,
-        _gc_ref: VMGcRef,
-    ) -> Rooted<Self> {
-        unreachable!()
-    }
-
     pub fn ty(&self, _store: impl AsContext) -> Result<HeapType> {
         match *self {}
     }

crates/wasmtime/src/runtime/gc/disabled/rooting.rs

@@ -1,12 +1,9 @@
-use crate::prelude::*;
 use crate::runtime::vm::{GcStore, VMGcRef};
 use crate::{
     runtime::Uninhabited,
     store::{AutoAssertNoGc, StoreOpaque},
     AsContext, AsContextMut, GcRef, Result, RootedGcRef,
 };
-use core::any::Any;
-use core::ffi::c_void;
 use core::fmt::{self, Debug};
 use core::hash::{Hash, Hasher};
 use core::marker;
@@ -46,13 +43,6 @@ impl RootSet {
     }
 
     pub(crate) fn exit_lifo_scope(&mut self, _gc_store: Option<&mut GcStore>, _scope: usize) {}
-
-    pub(crate) fn with_lifo_scope<T>(
-        store: &mut StoreOpaque,
-        f: impl FnOnce(&mut StoreOpaque) -> T,
-    ) -> T {
-        f(store)
-    }
 }
 
 /// This type is disabled because the `gc` cargo feature was not enabled at
@@ -124,10 +114,6 @@ impl<T: GcRef> Rooted<T> {
     ) -> Result<bool> {
         a.assert_unreachable()
     }
-
-    pub(crate) fn unchecked_cast<U: GcRef>(self) -> Rooted<U> {
-        match self.inner {}
-    }
 }
 
 /// This type has been disabled because the `gc` cargo feature was not enabled
@@ -197,10 +183,6 @@ impl<T> ManuallyRooted<T>
 where
     T: GcRef,
 {
-    pub(crate) fn comes_from_same_store(&self, _store: &StoreOpaque) -> bool {
-        match self.inner {}
-    }
-
     pub fn clone(&self, _store: impl AsContextMut) -> Self {
         match self.inner {}
     }
@@ -216,10 +198,6 @@ where
     pub fn into_rooted(self, _context: impl AsContextMut) -> Rooted<T> {
         match self.inner {}
     }
-
-    pub(crate) fn unchecked_cast<U: GcRef>(self) -> ManuallyRooted<U> {
-        match self.inner {}
-    }
 }
 
 impl<T: GcRef> RootedGcRefImpl<T> for ManuallyRooted<T> {