Struct rustc_query_system::query::caches::ArenaCache

pub struct ArenaCache<'tcx, K, V> {
    arena: WorkerLocal<TypedArena<(V, DepNodeIndex)>>,
    phantom: PhantomData<(K, &'tcx V)>,
}

Fields

arena: WorkerLocal<TypedArena<(V, DepNodeIndex)>>

phantom: PhantomData<(K, &'tcx V)>

Trait Implementations

impl<'tcx, K, V> Default for ArenaCache<'tcx, K, V>

pub fn default() -> Self

Returns the "default value" for a type.

impl<'tcx, K, V: 'tcx> QueryCache for ArenaCache<'tcx, K, V> where
    K: Eq + Hash + Clone + Debug, 

type Key = K

type Sharded = FxHashMap<K, &'tcx (V, DepNodeIndex)>

pub fn lookup<D, Q, R, OnHit, OnMiss>(
    &self,
    state: &QueryState<D, Q, Self>,
    key: K,
    on_hit: OnHit,
    on_miss: OnMiss
) -> R where
    OnHit: FnOnce(&&'tcx V, DepNodeIndex) -> R,
    OnMiss: FnOnce(K, QueryLookup<'_, D, Q, K, Self::Sharded>) -> R, 

Checks if the query is already computed and in the cache. It returns the shard index and a lock guard to the shard, which will be used if the query is not in the cache and we need to compute it.

pub fn complete(
    &self,
    lock_sharded_storage: &mut Self::Sharded,
    key: K,
    value: V,
    index: DepNodeIndex
) -> Self::Stored

pub fn iter<R, L>(
    &self,
    shards: &Sharded<L>,
    get_shard: impl Fn(&mut L) -> &mut Self::Sharded,
    f: impl for<'a> FnOnce(Box<dyn Iterator<Item = (&'a K, &'a V, DepNodeIndex)> + 'a>) -> R
) -> R

impl<'tcx, K: Eq + Hash, V: 'tcx> QueryStorage for ArenaCache<'tcx, K, V>

type Value = V

type Stored = &'tcx V

pub fn store_nocache(&self, value: Self::Value) -> Self::Stored

Store a value without putting it in the cache. This is meant to be used with cycle errors.