Struct Steal

pub struct Steal<T> {
    value: RwLock<Option<T>>,
}

The Steal struct is intended to used as the value for a query. Specifically, we sometimes have queries (cough MIR cough) where we create a large, complex value that we want to iteratively update (e.g., optimize). We could clone the value for each optimization, but that’d be expensive. And yet we don’t just want to mutate it in place, because that would spoil the idea that queries are these pure functions that produce an immutable value (since if you did the query twice, you could observe the mutations). So instead we have the query produce a &'tcx Steal<mir::Body<'tcx>> (to be very specific). Now we can read from this as much as we want (using borrow()), but you can also steal(). Once you steal, any further attempt to read will panic. Therefore, we know that – assuming no ICE – nobody is observing the fact that the MIR was updated.

Obviously, whenever you have a query that yields a Steal value, you must treat it with caution, and make sure that you know that – once the value is stolen – it will never be read from again.

Fields

value: RwLock<Option<T>>

Implementations

impl<T> Steal<T>

pub fn new(value: T) -> Self

pub fn borrow(&self) -> MappedReadGuard<'_, T>

pub fn get_mut(&mut self) -> &mut T

pub fn steal(&self) -> T

pub fn is_stolen(&self) -> bool

Writers of rustc drivers often encounter stealing issues. This function makes it possible to handle these errors gracefully.

This should not be used within rustc as it leaks information not tracked by the query system, breaking incremental compilation.

Trait Implementations

impl<T: Debug> Debug for Steal<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<CTX, T: HashStable<CTX>> HashStable<CTX> for Steal<T>

fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher)

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.