Restructure feature gating to fix CI warnings

Author: arjunr2

Cargo.toml

@@ -523,14 +523,9 @@ gc-drc = ["gc", "wasmtime/gc-drc", "wasmtime-cli-flags/gc-drc"]
 gc-null = ["gc", "wasmtime/gc-null", "wasmtime-cli-flags/gc-null"]
 pulley = ["wasmtime-cli-flags/pulley"]
 stack-switching = ["wasmtime/stack-switching", "wasmtime-cli-flags/stack-switching"]
-# `rr` only configures the base infrastructure and is not practically useful by itself
-# Use `rr-component` or `rr-core` for generating record/replay events for components/core wasm
-# respectively
-# Use `rr-validate` for additional validation checks over the above two features
-rr = ["wasmtime-cli-flags/rr"]
-rr-component = ["wasmtime/rr-component", "rr"]
-rr-core = ["wasmtime/rr-core", "rr"]
-rr-validate = ["wasmtime/rr-validate", "wasmtime-cli-flags/rr-validate"]
+rr = ["wasmtime/rr", "wasmtime-cli-flags/rr"]
+rr-component = ["rr", "wasmtime/rr-component"]
+rr-validate = ["rr", "wasmtime/rr-validate", "wasmtime-cli-flags/rr-validate"]
 
 # CLI subcommands for the `wasmtime` executable. See `wasmtime $cmd --help`
 # for more information on each subcommand.

crates/wasmtime/Cargo.toml

@@ -405,16 +405,12 @@ component-model-async-bytes = [
   "dep:bytes",
 ]
 
-# `rr` only configures the base infrastructure and is not practically useful by itself
-# Use `rr-component` or `rr-core` for generating record/replay events for components/core wasm
-# respectively
-rr = ["dep:embedded-io"]
-# RR for components
+# Enables support for record/replay for components
 rr-component = ["component-model", "rr"]
-# RR for core wasm
-rr-core = ["rr"]
+# Enable support for the common base infrastructure of record/replay
+# By default, this supports core wasm `rr`. For components, enable `rr-component`
+rr = ["dep:embedded-io"]
 
-# Support for validation signatures/checks during record/replay respectively.
-# This feature only makes sense if 'rr-component' or 'rr-core' is enabled
+# Enables record/replay with support for additional validation signatures/checks.
 rr-validate = ["rr"]
 

crates/wasmtime/src/runtime/component/func/options.rs

@@ -4,12 +4,13 @@ use crate::component::matching::InstanceType;
 use crate::component::resources::{HostResourceData, HostResourceIndex, HostResourceTables};
 use crate::component::{Instance, ResourceType};
 use crate::prelude::*;
-#[cfg(all(feature = "rr", feature = "rr-validate"))]
-use crate::rr::Validate;
 #[cfg(feature = "rr-component")]
-use crate::rr::component_events::{MemorySliceWriteEvent, ReallocEntryEvent, ReallocReturnEvent};
-#[cfg(feature = "rr-component")]
-use crate::rr::{RREvent, RecordBuffer, Recorder, ReplayError, Replayer};
+use crate::rr::{
+    RREvent, RecordBuffer, Recorder, ReplayError, Replayer,
+    component_events::MemorySliceWriteEvent, component_events::ReallocEntryEvent,
+};
+#[cfg(all(feature = "rr-component", feature = "rr-validate"))]
+use crate::rr::{Validate, component_events::ReallocReturnEvent};
 use crate::runtime::vm::component::{
     CallContexts, ComponentInstance, InstanceFlags, ResourceTable, ResourceTables,
 };
@@ -491,7 +492,7 @@ impl<'a, T: 'static> LowerContext<'a, T> {
             .0
             .record_event(|| ReallocEntryEvent::new(old, old_size, old_align, new_size))?;
         let result = self.realloc_inner(old, old_size, old_align, new_size);
-        #[cfg(feature = "rr-component")]
+        #[cfg(all(feature = "rr-component", feature = "rr-validate"))]
         self.store
             .0
             .record_event_validation(|| ReallocReturnEvent::new(&result))?;
@@ -676,7 +677,8 @@ impl<'a, T: 'static> LowerContext<'a, T> {
         while !complete {
             let buf = self.store.0.replay_buffer_mut().unwrap();
             let event = buf.next_event()?;
-            let _run_validate = buf.settings().validate && buf.trace_settings().add_validation;
+            #[cfg(feature = "rr-validate")]
+            let run_validate = buf.settings().validate && buf.trace_settings().add_validation;
             match event {
                 RREvent::ComponentHostFuncReturn(e) => {
                     // End of the lowering process
@@ -692,21 +694,21 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                     let _result =
                         self.realloc_inner(e.old_addr, e.old_size, e.old_align, e.new_size);
                     #[cfg(feature = "rr-validate")]
-                    if _run_validate {
+                    if run_validate {
                         _realloc_stack.push(_result);
                     }
                 }
                 // No return value to validate for lower/lower-store; store error and just check that entry happened before
                 RREvent::ComponentLowerReturn(e) => {
                     #[cfg(feature = "rr-validate")]
-                    if _run_validate {
+                    if run_validate {
                         _lower_stack.pop().ok_or(ReplayError::InvalidOrdering)?;
                     }
                     lowering_error = e.ret().map_err(Into::into).err();
                 }
                 RREvent::ComponentLowerStoreReturn(e) => {
                     #[cfg(feature = "rr-validate")]
-                    if _run_validate {
+                    if run_validate {
                         _lower_store_stack
                             .pop()
                             .ok_or(ReplayError::InvalidOrdering)?;
@@ -730,21 +732,21 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                 RREvent::ComponentReallocReturn(_e) =>
                 {
                     #[cfg(feature = "rr-validate")]
-                    if _run_validate {
+                    if run_validate {
                         lowering_error = _e.validate(&_realloc_stack.pop().unwrap()).err()
                     }
                 }
                 RREvent::ComponentLowerEntry(_) => {
                     // All we want here is ensuring Entry occurs before Return
                     #[cfg(feature = "rr-validate")]
-                    if _run_validate {
+                    if run_validate {
                         _lower_stack.push(())
                     }
                 }
                 RREvent::ComponentLowerStoreEntry(_) => {
                     // All we want here is ensuring Entry occurs before Return
                     #[cfg(feature = "rr-validate")]
-                    if _run_validate {
+                    if run_validate {
                         _lower_store_stack.push(())
                     }
                 }

crates/wasmtime/src/runtime/func.rs

@@ -1485,7 +1485,7 @@ impl Func {
 /// Convenience methods to inject record + replay logic
 mod rr_hooks {
     use super::*;
-    #[cfg(feature = "rr-core")]
+    #[cfg(feature = "rr")]
     use crate::rr::core_events::HostFuncReturnEvent;
     use wasmtime_environ::WasmFuncType;
 
@@ -1496,7 +1496,7 @@ mod rr_hooks {
         wasm_func_type: &WasmFuncType,
         store: &mut StoreOpaque,
     ) -> Result<()> {
-        #[cfg(all(feature = "rr-core", feature = "rr-validate"))]
+        #[cfg(all(feature = "rr", feature = "rr-validate"))]
         {
             // Record/replay the raw parameter args
             use crate::rr::core_events::HostFuncEntryEvent;
@@ -1518,7 +1518,7 @@ mod rr_hooks {
         store: &mut StoreOpaque,
     ) -> Result<()> {
         // Record the return values
-        #[cfg(feature = "rr-core")]
+        #[cfg(feature = "rr")]
         store.record_event(|| {
             let func_type = wasm_func_type;
             let num_results = func_type.params().len();
@@ -1535,7 +1535,7 @@ mod rr_hooks {
         wasm_func_type: &WasmFuncType,
         store: &mut StoreOpaque,
     ) -> Result<()> {
-        #[cfg(feature = "rr-core")]
+        #[cfg(feature = "rr")]
         store.next_replay_event_and(|event: HostFuncReturnEvent| {
             event.move_into_slice(args);
             Ok(())

crates/wasmtime/src/runtime/rr/events/component_events.rs

@@ -43,6 +43,7 @@ impl HostFuncEntryEvent {
         }
     }
 }
+#[cfg(feature = "rr-validate")]
 impl Validate<TypeFunc> for HostFuncEntryEvent {
     fn validate(&self, expect_types: &TypeFunc) -> Result<(), ReplayError> {
         self.log();
@@ -143,6 +144,7 @@ generic_new_result_events! {
     LowerStoreReturnEvent => ((), EventActionError::LowerStoreError)
 }
 
+#[cfg(feature = "rr-validate")]
 impl Validate<Result<usize>> for ReallocReturnEvent {
     /// We can check that realloc is deterministic (as expected by the engine)
     fn validate(&self, expect_ret: &Result<usize>) -> Result<(), ReplayError> {

crates/wasmtime/src/runtime/rr/events/core_events.rs

@@ -23,6 +23,7 @@ impl HostFuncEntryEvent {
         }
     }
 }
+#[cfg(feature = "rr-validate")]
 impl Validate<CoreFuncArgTypes> for HostFuncEntryEvent {
     fn validate(&self, expect_types: &CoreFuncArgTypes) -> Result<(), ReplayError> {
         self.log();

crates/wasmtime/src/runtime/rr/events/mod.rs

@@ -1,3 +1,4 @@
+#[cfg(any(feature = "rr-component", feature = "rr-validate"))]
 use super::ReplayError;
 use crate::ValRaw;
 use crate::prelude::*;
@@ -97,6 +98,7 @@ where
 /// Note however that some [`Validate`] implementations are present even
 /// when feature `rr-validate` is disabled, when validation is needed
 /// for a faithful replay (e.g. [`component_events::InstantiationEvent`]).
+#[cfg(any(feature = "rr-component", feature = "rr-validate"))]
 pub trait Validate<T: ?Sized> {
     /// Perform a validation of the event to ensure replay consistency
     fn validate(&self, expect: &T) -> Result<(), ReplayError>;
@@ -110,6 +112,7 @@ pub trait Validate<T: ?Sized> {
     }
 }
 
+#[cfg(any(feature = "rr-component", feature = "rr-validate"))]
 impl<T> Validate<T> for T
 where
     T: PartialEq + fmt::Debug,

crates/wasmtime/src/runtime/rr/mod.rs

@@ -12,16 +12,15 @@ use crate::prelude::*;
 use core::fmt;
 use events::EventActionError;
 use serde::{Deserialize, Serialize};
-// Use component/core events internally even without feature flags enabled
+// Use component events internally even without feature flags enabled
 // so that [`RREvent`] has a well-defined serialization format, but export
 // it for other modules only when enabled
+#[cfg(any(feature = "rr-validate", feature = "rr-component"))]
+pub use events::Validate;
 use events::component_events as __component_events;
 #[cfg(feature = "rr-component")]
 pub use events::component_events;
-use events::core_events as __core_events;
-#[cfg(feature = "rr-core")]
-pub use events::core_events;
-pub use events::{Validate, marker_events};
+pub use events::{core_events, marker_events};
 pub use io::{RecordWriter, ReplayReader};
 
 /// Encapsulation of event types comprising an [`RREvent`] sum type
@@ -93,9 +92,9 @@ rr_event! {
     CustomMessage(marker_events::CustomMessageEvent),
 
     /// Call into host function from Core Wasm
-    CoreHostFuncEntry(__core_events::HostFuncEntryEvent),
+    CoreHostFuncEntry(core_events::HostFuncEntryEvent),
     /// Return from host function to Core Wasm
-    CoreHostFuncReturn(__core_events::HostFuncReturnEvent),
+    CoreHostFuncReturn(core_events::HostFuncReturnEvent),
 
     // REQUIRED events for replay
     //
@@ -209,6 +208,7 @@ pub trait Recorder {
 
     /// Record a event only when validation is requested
     #[inline]
+    #[cfg(feature = "rr-validate")]
     fn record_event_validation<T, F>(&mut self, f: F) -> Result<()>
     where
         T: Into<RREvent>,
@@ -231,9 +231,19 @@ pub trait Replayer: Iterator<Item = RREvent> {
         Self: Sized;
 
     /// Get settings associated with the replay process
+    #[allow(
+        unused,
+        reason = "currently used only for validation resulting in \
+    many unnecessary feature gates. will expand in the future to more features"
+    )]
     fn settings(&self) -> &ReplaySettings;
 
     /// Get the settings (embedded within the trace) during recording
+    #[allow(
+        unused,
+        reason = "currently used only for validation resulting in \
+    many unnecessary feature gates. will expand in the future to more features"
+    )]
     fn trace_settings(&self) -> &RecordSettings;
 
     // Provided Methods

crates/wasmtime/src/runtime/store.rs

@@ -1491,7 +1491,7 @@ impl StoreOpaque {
     /// if validation is enabled for recording
     ///
     /// Convenience wrapper around [`Recorder::record_event_validation`]
-    #[cfg(feature = "rr")]
+    #[cfg(feature = "rr-validate")]
     #[inline(always)]
     pub(crate) fn record_event_validation<T, F>(&mut self, f: F) -> Result<()>
     where
@@ -1527,7 +1527,7 @@ impl StoreOpaque {
     /// and if validation is enabled on replay, and run the validation check
     ///
     /// Convenience wrapper around [`Replayer::next_event_validation`]
-    #[cfg(all(feature = "rr", feature = "rr-validate"))]
+    #[cfg(feature = "rr-validate")]
     #[inline]
     pub(crate) fn next_replay_event_validation<T, Y>(
         &mut self,