Fix warnings for CI

Author: arjunr2

crates/environ/src/component/types.rs

@@ -1,4 +1,4 @@
-use crate::component::{FlatTypesStorage, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS};
+use crate::component::{MAX_FLAT_PARAMS, MAX_FLAT_RESULTS};
 use crate::{EntityType, ModuleInternedTypeIndex, ModuleTypes, PrimaryMap};
 use crate::{TypeTrace, prelude::*};
 use core::hash::{Hash, Hasher};
@@ -1386,6 +1386,83 @@ const fn max_flat(a: Option<u8>, b: Option<u8>) -> Option<u8> {
     }
 }
 
+/// Representation of flat types in 32-bit and 64-bit memory
+///
+/// This could be represented as `Vec<FlatType>` but on 64-bit architectures
+/// that's 24 bytes. Otherwise `FlatType` is 1 byte large and
+/// `MAX_FLAT_TYPES` is 16, so it should ideally be more space-efficient to
+/// use a flat array instead of a heap-based vector.
+#[derive(Debug)]
+pub struct FlatTypesStorage {
+    /// Representation for 32-bit memory
+    pub memory32: [FlatType; MAX_FLAT_TYPES],
+    /// Representation for 64-bit memory
+    pub memory64: [FlatType; MAX_FLAT_TYPES],
+
+    /// Tracks the number of flat types pushed into this storage. If this is
+    /// `MAX_FLAT_TYPES + 1` then this storage represents an un-reprsentable
+    /// type in flat types.
+    ///
+    /// This value should be the same on both `memory32` and `memory64`
+    pub len: u8,
+}
+
+impl FlatTypesStorage {
+    /// Create a new, empty storage for flat types
+    pub const fn new() -> FlatTypesStorage {
+        FlatTypesStorage {
+            memory32: [FlatType::I32; MAX_FLAT_TYPES],
+            memory64: [FlatType::I32; MAX_FLAT_TYPES],
+            len: 0,
+        }
+    }
+
+    /// Returns a reference to flat type representation
+    pub fn as_flat_types(&self) -> Option<FlatTypes<'_>> {
+        let len = usize::from(self.len);
+        if len > MAX_FLAT_TYPES {
+            assert_eq!(len, MAX_FLAT_TYPES + 1);
+            None
+        } else {
+            Some(FlatTypes {
+                memory32: &self.memory32[..len],
+                memory64: &self.memory64[..len],
+            })
+        }
+    }
+
+    /// Pushes a new flat type into this list using `t32` for 32-bit memories
+    /// and `t64` for 64-bit memories.
+    ///
+    /// Returns whether the type was actually pushed or whether this list of
+    /// flat types just exceeded the maximum meaning that it is now
+    /// unrepresentable with a flat list of types.
+    pub fn push(&mut self, t32: FlatType, t64: FlatType) -> bool {
+        let len = usize::from(self.len);
+        if len < MAX_FLAT_TYPES {
+            self.memory32[len] = t32;
+            self.memory64[len] = t64;
+            self.len += 1;
+            true
+        } else {
+            // If this was the first one to go over then flag the length as
+            // being incompatible with a flat representation.
+            if len == MAX_FLAT_TYPES {
+                self.len += 1;
+            }
+            false
+        }
+    }
+
+    /// Generate an iterator over the 32-bit flat encoding
+    pub fn iter32(&self) -> impl Iterator<Item = u8> {
+        self.memory32
+            .iter()
+            .take(self.len as usize)
+            .map(|f| f.byte_size())
+    }
+}
+
 /// Flat representation of a type in just core wasm types.
 pub struct FlatTypes<'a> {
     /// The flat representation of this type in 32-bit memories.
@@ -1417,6 +1494,17 @@ pub enum FlatType {
 }
 
 impl FlatType {
+    /// Constructs the "joined" representation for two flat types
+    pub fn join(&mut self, other: FlatType) {
+        if *self == other {
+            return;
+        }
+        *self = match (*self, other) {
+            (FlatType::I32, FlatType::F32) | (FlatType::F32, FlatType::I32) => FlatType::I32,
+            _ => FlatType::I64,
+        };
+    }
+
     /// Return the size in bytes for this flat type
     pub const fn byte_size(&self) -> u8 {
         match self {

crates/environ/src/component/types_builder.rs

@@ -840,96 +840,6 @@ where
     return idx;
 }
 
-/// Representation of flat types in 32-bit and 64-bit memory
-///
-/// This could be represented as `Vec<FlatType>` but on 64-bit architectures
-/// that's 24 bytes. Otherwise `FlatType` is 1 byte large and
-/// `MAX_FLAT_TYPES` is 16, so it should ideally be more space-efficient to
-/// use a flat array instead of a heap-based vector.
-#[derive(Debug)]
-pub struct FlatTypesStorage {
-    /// Representation for 32-bit memory
-    pub memory32: [FlatType; MAX_FLAT_TYPES],
-    /// Representation for 64-bit memory
-    pub memory64: [FlatType; MAX_FLAT_TYPES],
-
-    /// Tracks the number of flat types pushed into this storage. If this is
-    /// `MAX_FLAT_TYPES + 1` then this storage represents an un-reprsentable
-    /// type in flat types.
-    ///
-    /// This value should be the same on both `memory32` and `memory64`
-    pub len: u8,
-}
-
-impl FlatTypesStorage {
-    /// Create a new, empty storage for flat types
-    pub const fn new() -> FlatTypesStorage {
-        FlatTypesStorage {
-            memory32: [FlatType::I32; MAX_FLAT_TYPES],
-            memory64: [FlatType::I32; MAX_FLAT_TYPES],
-            len: 0,
-        }
-    }
-
-    /// Returns a reference to flat type representation
-    pub fn as_flat_types(&self) -> Option<FlatTypes<'_>> {
-        let len = usize::from(self.len);
-        if len > MAX_FLAT_TYPES {
-            assert_eq!(len, MAX_FLAT_TYPES + 1);
-            None
-        } else {
-            Some(FlatTypes {
-                memory32: &self.memory32[..len],
-                memory64: &self.memory64[..len],
-            })
-        }
-    }
-
-    /// Pushes a new flat type into this list using `t32` for 32-bit memories
-    /// and `t64` for 64-bit memories.
-    ///
-    /// Returns whether the type was actually pushed or whether this list of
-    /// flat types just exceeded the maximum meaning that it is now
-    /// unrepresentable with a flat list of types.
-    pub fn push(&mut self, t32: FlatType, t64: FlatType) -> bool {
-        let len = usize::from(self.len);
-        if len < MAX_FLAT_TYPES {
-            self.memory32[len] = t32;
-            self.memory64[len] = t64;
-            self.len += 1;
-            true
-        } else {
-            // If this was the first one to go over then flag the length as
-            // being incompatible with a flat representation.
-            if len == MAX_FLAT_TYPES {
-                self.len += 1;
-            }
-            false
-        }
-    }
-
-    /// Generate an iterator over the 32-bit flat encoding
-    pub fn iter32(&self) -> impl Iterator<Item = u8> {
-        self.memory32
-            .iter()
-            .take(self.len as usize)
-            .map(|f| f.byte_size())
-    }
-}
-
-impl FlatType {
-    /// Constructs the "joined" representation for two flat types
-    pub fn join(&mut self, other: FlatType) {
-        if *self == other {
-            return;
-        }
-        *self = match (*self, other) {
-            (FlatType::I32, FlatType::F32) | (FlatType::F32, FlatType::I32) => FlatType::I32,
-            _ => FlatType::I64,
-        };
-    }
-}
-
 #[derive(Default)]
 struct TypeInformationCache {
     records: PrimaryMap<TypeRecordIndex, TypeInformation>,

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

@@ -867,7 +867,7 @@ where
 
                 storage[0] = MaybeUninit::new(ValRaw::i32(status as i32));
                 rr::component_hooks::record_host_func_return(
-                    &mut storage[..1],
+                    &storage[..1],
                     types,
                     &InterfaceType::U32,
                     store.0,

crates/wasmtime/src/runtime/func.rs

@@ -1303,10 +1303,7 @@ impl Func {
         let nparams = ty.params().len();
         val_vec.reserve(nparams + ty.results().len());
 
-        let flat_params = ty
-            .params()
-            .into_iter()
-            .map(|x| x.to_wasm_type().byte_size());
+        let flat_params = ty.params().map(|x| x.to_wasm_type().byte_size());
 
         if !caller.store.0.replay_enabled() {
             rr::core_hooks::record_validate_host_func_entry(
@@ -1332,10 +1329,7 @@ impl Func {
                 values_vec[i] = ret.to_raw(&mut caller.store)?;
             }
 
-            let flat_results = ty
-                .results()
-                .into_iter()
-                .map(|x| x.to_wasm_type().byte_size());
+            let flat_results = ty.results().map(|x| x.to_wasm_type().byte_size());
             rr::core_hooks::record_host_func_return(values_vec, flat_results, &mut caller.store.0)?;
         } else {
             rr::core_hooks::replay_validate_host_func_entry(

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

@@ -194,8 +194,7 @@ where
             params.store(&mut store, ty, dst)?;
         }
 
-        let storage_len =
-            mem::size_of_val::<Storage<_, _>>(&mut storage) / mem::size_of::<ValRaw>();
+        let storage_len = mem::size_of_val::<Storage<_, _>>(&storage) / mem::size_of::<ValRaw>();
         let storage_slice: *mut Storage<_, _> = &mut storage;
         let storage_slice = storage_slice.cast::<ValRaw>();
         let storage_slice = core::ptr::slice_from_raw_parts_mut(storage_slice, storage_len);

crates/wasmtime/src/runtime/rr.rs

@@ -43,7 +43,11 @@ impl FlatBytes for MaybeUninit<ValRaw> {
 
 /// Convenience method hooks for injecting event recording/replaying in the rest of the engine
 mod hooks;
-pub(crate) use hooks::{ConstMemorySliceCell, MemorySliceCell, component_hooks, core_hooks};
+pub(crate) use hooks::core_hooks;
+#[cfg(feature = "component-model")]
+pub(crate) use hooks::{
+    component_hooks, component_hooks::ConstMemorySliceCell, component_hooks::MemorySliceCell,
+};
 
 /// Core infrastructure for RR support
 #[cfg(feature = "rr")]

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

@@ -1,108 +1,5 @@
-#[cfg(feature = "rr-component")]
-use crate::rr::{RecordBuffer, Recorder, component_events::MemorySliceWriteEvent};
-
-use core::ops::{Deref, DerefMut};
-
 /// Component specific RR hooks that use `component-model` feature gating
+#[cfg(feature = "component-model")]
 pub mod component_hooks;
 /// Core RR hooks
 pub mod core_hooks;
-
-/// Same as [`ConstMemorySliceCell`] except allows for dynamically sized slices.
-///
-/// Prefer the above for efficiency if slice size is known statically.
-///
-/// **Note**: The correct operation of this type relies of several invariants.
-/// See [`ConstMemorySliceCell`] for detailed description on the role
-/// of these types.
-pub struct MemorySliceCell<'a> {
-    pub bytes: &'a mut [u8],
-    #[cfg(feature = "rr-component")]
-    pub offset: usize,
-    #[cfg(feature = "rr-component")]
-    pub recorder: Option<&'a mut RecordBuffer>,
-}
-impl<'a> Deref for MemorySliceCell<'a> {
-    type Target = [u8];
-    fn deref(&self) -> &Self::Target {
-        self.bytes
-    }
-}
-impl DerefMut for MemorySliceCell<'_> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.bytes
-    }
-}
-impl Drop for MemorySliceCell<'_> {
-    /// Drop serves as a recording hook for stores to the memory slice
-    fn drop(&mut self) {
-        #[cfg(feature = "rr-component")]
-        if let Some(buf) = &mut self.recorder {
-            buf.record_event(|| MemorySliceWriteEvent {
-                offset: self.offset,
-                bytes: self.bytes.to_vec(),
-            })
-            .unwrap();
-        }
-    }
-}
-
-/// Zero-cost encapsulation type for a statically sized slice of mutable memory
-///
-/// # Purpose and Usage (Read Carefully!)
-///
-/// This type (and its dynamic counterpart [`MemorySliceCell`]) are critical to
-/// record/replay (RR) support in Wasmtime. In practice, all lowering operations utilize
-/// a [`LowerContext`], which provides a capability to modify guest Wasm module state in
-/// the following ways:
-///
-/// 1. Write to slices of memory with [`get`](LowerContext::get)/[`get_dyn`](LowerContext::get_dyn)
-/// 2. Movement of memory with [`realloc`](LowerContext::realloc)
-///
-/// The above are intended to be the narrow waists for recording changes to guest state, and
-/// should be the **only** interfaces used during lowerng. In particular,
-/// [`get`](LowerContext::get)/[`get_dyn`](LowerContext::get_dyn) return
-/// ([`ConstMemorySliceCell`]/[`MemorySliceCell`]), which implement [`Drop`]
-/// allowing us a hook to just capture the final aggregate changes made to guest memory by the host.
-///
-/// ## Critical Invariants
-///
-/// Typically recording would need to know both when the slice was borrowed AND when it was
-/// dropped, since memory movement with [`realloc`](LowerContext::realloc) can be interleaved between
-/// borrows and drops, and replays would have to be aware of this. **However**, with this abstraction,
-/// we can be more efficient and get away with **only** recording drops, because of the implicit interaction between
-/// [`realloc`](LowerContext::realloc) and [`get`](LowerContext::get)/[`get_dyn`](LowerContext::get_dyn),
-/// which both take a `&mut self`. Since the latter implements [`Drop`], which also takes a `&mut self`,
-/// the compiler will automatically enforce that drops of this type need to be triggered before a
-/// [`realloc`](LowerContext::realloc), preventing any interleavings in between the borrow and drop of the slice.
-pub struct ConstMemorySliceCell<'a, const N: usize> {
-    pub bytes: &'a mut [u8; N],
-    #[cfg(feature = "rr-component")]
-    pub offset: usize,
-    #[cfg(feature = "rr-component")]
-    pub recorder: Option<&'a mut RecordBuffer>,
-}
-impl<'a, const N: usize> Deref for ConstMemorySliceCell<'a, N> {
-    type Target = [u8; N];
-    fn deref(&self) -> &Self::Target {
-        self.bytes
-    }
-}
-impl<'a, const N: usize> DerefMut for ConstMemorySliceCell<'a, N> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.bytes
-    }
-}
-impl<'a, const N: usize> Drop for ConstMemorySliceCell<'a, N> {
-    /// Drops serves as a recording hook for stores to the memory slice
-    fn drop(&mut self) {
-        #[cfg(feature = "rr-component")]
-        if let Some(buf) = &mut self.recorder {
-            buf.record_event(|| MemorySliceWriteEvent {
-                offset: self.offset,
-                bytes: self.bytes.to_vec(),
-            })
-            .unwrap();
-        }
-    }
-}