Move Steal to rustc_data_structures.
This commit is contained in:
parent
cf9cf7c923
commit
41c44b498f
11 changed files with 18 additions and 20 deletions
|
@ -14,10 +14,10 @@ macro_rules! arena_types {
|
|||
[] layouts: rustc_target::abi::Layout,
|
||||
// AdtDef are interned and compared by address
|
||||
[] adt_def: rustc_middle::ty::AdtDef,
|
||||
[] steal_mir: rustc_middle::ty::steal::Steal<rustc_middle::mir::Body<$tcx>>,
|
||||
[] steal_mir: rustc_data_structures::steal::Steal<rustc_middle::mir::Body<$tcx>>,
|
||||
[decode] mir: rustc_middle::mir::Body<$tcx>,
|
||||
[] steal_promoted:
|
||||
rustc_middle::ty::steal::Steal<
|
||||
rustc_data_structures::steal::Steal<
|
||||
rustc_index::vec::IndexVec<
|
||||
rustc_middle::mir::Promoted,
|
||||
rustc_middle::mir::Body<$tcx>
|
||||
|
|
|
@ -184,15 +184,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for ty::FloatVid {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, T> HashStable<StableHashingContext<'a>> for ty::steal::Steal<T>
|
||||
where
|
||||
T: HashStable<StableHashingContext<'a>>,
|
||||
{
|
||||
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
|
||||
self.borrow().hash_stable(hcx, hasher);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> HashStable<StableHashingContext<'a>> for crate::middle::privacy::AccessLevels {
|
||||
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
|
||||
hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
|
||||
|
|
|
@ -14,7 +14,6 @@ use crate::mir::interpret::{self, Allocation, ConstValue, Scalar};
|
|||
use crate::mir::{Body, Field, Local, Place, PlaceElem, ProjectionKind, Promoted};
|
||||
use crate::traits;
|
||||
use crate::ty::query::{self, TyCtxtAt};
|
||||
use crate::ty::steal::Steal;
|
||||
use crate::ty::subst::{GenericArg, GenericArgKind, InternalSubsts, Subst, SubstsRef, UserSubsts};
|
||||
use crate::ty::TyKind::*;
|
||||
use crate::ty::{
|
||||
|
@ -33,6 +32,7 @@ use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
|
|||
use rustc_data_structures::stable_hasher::{
|
||||
hash_stable_hashmap, HashStable, StableHasher, StableVec,
|
||||
};
|
||||
use rustc_data_structures::steal::Steal;
|
||||
use rustc_data_structures::sync::{self, Lock, Lrc, WorkerLocal};
|
||||
use rustc_data_structures::unhash::UnhashMap;
|
||||
use rustc_errors::ErrorReported;
|
||||
|
|
|
@ -106,7 +106,6 @@ pub mod outlives;
|
|||
pub mod print;
|
||||
pub mod query;
|
||||
pub mod relate;
|
||||
pub mod steal;
|
||||
pub mod subst;
|
||||
pub mod trait_def;
|
||||
pub mod util;
|
||||
|
|
|
@ -28,13 +28,13 @@ use crate::traits::query::{
|
|||
};
|
||||
use crate::traits::specialization_graph;
|
||||
use crate::traits::{self, ImplSource};
|
||||
use crate::ty::steal::Steal;
|
||||
use crate::ty::subst::{GenericArg, SubstsRef};
|
||||
use crate::ty::util::AlwaysRequiresDrop;
|
||||
use crate::ty::{self, AdtSizedConstraint, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt};
|
||||
use rustc_data_structures::fingerprint::Fingerprint;
|
||||
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
|
||||
use rustc_data_structures::stable_hasher::StableVec;
|
||||
use rustc_data_structures::steal::Steal;
|
||||
use rustc_data_structures::svh::Svh;
|
||||
use rustc_data_structures::sync::Lrc;
|
||||
use rustc_errors::ErrorReported;
|
||||
|
|
|
@ -1,44 +0,0 @@
|
|||
use rustc_data_structures::sync::{MappedReadGuard, ReadGuard, RwLock};
|
||||
|
||||
/// 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.
|
||||
//
|
||||
// FIXME(#41710): what is the best way to model linear queries?
|
||||
pub struct Steal<T> {
|
||||
value: RwLock<Option<T>>,
|
||||
}
|
||||
|
||||
impl<T> Steal<T> {
|
||||
pub fn new(value: T) -> Self {
|
||||
Steal { value: RwLock::new(Some(value)) }
|
||||
}
|
||||
|
||||
pub fn borrow(&self) -> MappedReadGuard<'_, T> {
|
||||
ReadGuard::map(self.value.borrow(), |opt| match *opt {
|
||||
None => bug!("attempted to read from stolen value"),
|
||||
Some(ref v) => v,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn steal(&self) -> T {
|
||||
let value_ref = &mut *self.value.try_write().expect("stealing value which is locked");
|
||||
let value = value_ref.take();
|
||||
value.expect("attempt to read from stolen value")
|
||||
}
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue