Clean build with gc disabled (cargo check -p wasmtime --no-default-features --features runtime).

Author: cfallin

crates/environ/src/gc/drc.rs

@@ -38,6 +38,6 @@ impl GcTypeLayouts for DrcTypeLayouts {
     }
 
     fn exn_layout(&self, ty: &WasmExnType) -> GcExceptionLayout {
-       common_exn_layout(ty, HEADER_SIZE, HEADER_ALIGN)
+        common_exn_layout(ty, HEADER_SIZE, HEADER_ALIGN)
     }
 }

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

@@ -1,13 +1,15 @@
 use crate::Result;
 use crate::runtime::types::TagType;
-use crate::store::InstanceId;
 use crate::trampoline::generate_tag_export;
 use crate::{
     AsContext, AsContextMut,
     store::{StoreInstanceId, StoreOpaque},
 };
 use wasmtime_environ::{DefinedTagIndex, VMSharedTypeIndex};
 
+#[cfg(feature = "gc")]
+use crate::store::InstanceId;
+
 /// A WebAssembly `tag`.
 #[derive(Copy, Clone, Debug)]
 #[repr(C)] // here for the C API in the future
@@ -121,6 +123,7 @@ impl Tag {
     /// used to "serialize" the tag as safe (tamper-proof,
     /// bounds-checked) values, e.g. within the GC store for an
     /// exception object.
+    #[cfg(feature = "gc")]
     pub(crate) fn to_raw_indices(&self) -> (InstanceId, DefinedTagIndex) {
         (self.instance.instance(), self.index)
     }
@@ -131,6 +134,7 @@ impl Tag {
     /// # Panics
     ///
     /// Panics if the indices are out-of-bounds in the given store.
+    #[cfg(feature = "gc")]
     pub(crate) fn from_raw_indices(
         store: &StoreOpaque,
         instance: InstanceId,

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

@@ -11,6 +11,7 @@
 mod anyref;
 mod arrayref;
 mod eqref;
+mod exnref;
 mod externref;
 mod i31;
 mod rooting;
@@ -19,6 +20,7 @@ mod structref;
 pub use anyref::*;
 pub use arrayref::*;
 pub use eqref::*;
+pub use exnref::*;
 pub use externref::*;
 pub use i31::*;
 pub use rooting::*;

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

@@ -0,0 +1,70 @@
+//! `exnref` implementation stubs when GC is disabled.
+
+use crate::{
+    AsContext, AsContextMut, ExnType, GcRefImpl, HeapType, Result, Rooted, Tag, Val,
+    store::{AutoAssertNoGc, StoreContextMut, StoreOpaque},
+};
+
+/// Support for `ExnRefPre` disabled at compile time because the `gc`
+/// cargo feature was not enabled.
+pub enum ExnRefPre {}
+
+/// Support for `exnref` disabled at compile time because the `gc`
+/// cargo feature was not enabled.
+pub enum ExnRef {}
+
+impl GcRefImpl for ExnRef {}
+
+impl ExnRef {
+    pub unsafe fn from_raw(_store: impl AsContextMut, _raw: u32) -> Option<Rooted<Self>> {
+        None
+    }
+
+    pub(crate) fn _from_raw(_store: &mut AutoAssertNoGc, _raw: u32) -> Option<Rooted<Self>> {
+        None
+    }
+
+    pub unsafe fn to_raw(&self, _store: impl AsContextMut) -> Result<u32> {
+        Ok(0)
+    }
+
+    pub(crate) unsafe fn _to_raw(&self, _store: &mut AutoAssertNoGc<'_>) -> Result<u32> {
+        Ok(0)
+    }
+
+    pub fn ty(&self, _store: impl AsContext) -> Result<ExnType> {
+        match *self {}
+    }
+
+    pub(crate) fn _ty(&self, _store: &StoreOpaque) -> Result<ExnType> {
+        match *self {}
+    }
+
+    pub fn matches_ty(&self, _store: impl AsContext, _ty: &HeapType) -> Result<bool> {
+        match *self {}
+    }
+
+    pub(crate) fn _matches_ty(&self, _store: &StoreOpaque, _ty: &HeapType) -> Result<bool> {
+        match *self {}
+    }
+
+    pub fn tag(&self, _store: impl AsContextMut) -> Result<Tag> {
+        match *self {}
+    }
+
+    pub fn fields<'a, T: 'static>(
+        &self,
+        _store: impl Into<StoreContextMut<'a, T>>,
+    ) -> Result<impl ExactSizeIterator<Item = Val> + 'a + '_> {
+        match *self {}
+        Ok([].into_iter())
+    }
+
+    pub fn field(&self, _store: impl AsContextMut, _index: usize) -> Result<Val> {
+        match *self {}
+    }
+
+    pub fn set_field(&self, _store: impl AsContextMut, _index: usize, _value: Val) -> Result<()> {
+        match *self {}
+    }
+}

crates/wasmtime/src/runtime/instance.rs

@@ -536,6 +536,7 @@ impl Instance {
         self.get_export(store, name)?.into_tag()
     }
 
+    #[cfg(feature = "gc")]
     pub(crate) fn id(&self) -> InstanceId {
         self.id.instance()
     }

crates/wasmtime/src/runtime/types.rs

@@ -2930,7 +2930,6 @@ impl ExnType {
         self.type_index() == other.type_index()
     }
 
-    #[cfg(feature = "gc")]
     pub(crate) fn registered_type(&self) -> &RegisteredType {
         &self.registered_type
     }

crates/wasmtime/src/runtime/vm/gc/enabled/null.rs

@@ -17,7 +17,8 @@ use crate::{
 use core::ptr::NonNull;
 use core::{alloc::Layout, any::Any, num::NonZeroU32};
 use wasmtime_environ::{
-    null::NullTypeLayouts, GcArrayLayout, GcExceptionLayout, GcStructLayout, GcTypeLayouts, VMGcKind, VMSharedTypeIndex
+    GcArrayLayout, GcExceptionLayout, GcStructLayout, GcTypeLayouts, VMGcKind, VMSharedTypeIndex,
+    null::NullTypeLayouts,
 };
 
 /// The null collector.