wasmtime/runtime/vm/
always_mut.rs

1use core::fmt;
2
3/// A helper types that is `Send` if `T` is `Sync`.
4///
5/// This structure is a newtype wrapper around the `T` type parameter. What
6/// makes this a utility is the fact that it contains an `unsafe impl Sync`
7/// implementation for the type when `T` is `Send`. This is then coupled with
8/// the fact that there is no ability to access a shared reference, `&T`, from
9/// this type. Instead all access is done through `&mut T`.
10///
11/// This means that accessing the `T` in this data structure always requires
12/// exclusive `&mut self` access. This provides the trivial guarantee that this
13/// type is safe to share across threads because if you do so then you're just
14/// not able to do anything with it.
15#[derive(Default /* Do not derive traits with &self here, that's not sound */)]
16#[repr(transparent)]
17pub struct AlwaysMut<T>(T);
18
19// SAFETY: this is the purpose for existence of this type, meaning that if `T`
20// is `Send` then this type is `Sync` because it statically disallows shared
21// access to `T`.
22unsafe impl<T: Send> Sync for AlwaysMut<T> {}
23
24impl<T> AlwaysMut<T> {
25    /// Creates a new [`AlwaysMut`] with the provided value.
26    pub fn new(value: T) -> AlwaysMut<T> {
27        AlwaysMut(value)
28    }
29
30    /// Return a mutable reference to the underlying data in this [`AlwaysMut`]
31    pub fn get_mut(&mut self) -> &mut T {
32        &mut self.0
33    }
34
35    /// Consume this [`AlwaysMut`], returning the underlying data.
36    #[cfg(feature = "async")]
37    pub fn into_inner(self) -> T {
38        self.0
39    }
40}
41
42impl<T> From<T> for AlwaysMut<T> {
43    fn from(val: T) -> AlwaysMut<T> {
44        AlwaysMut::new(val)
45    }
46}
47
48impl<T> fmt::Debug for AlwaysMut<T> {
49    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
50        f.debug_struct("AlwaysMut").finish_non_exhaustive()
51    }
52}
wasmtime/runtime/vm/always_mut.rs

wasmtime/runtime/vm/
always_mut.rs
