Struct rustc_query_impl::QueryCtxt

pub struct QueryCtxt<'tcx> {
    pub tcx: TyCtxt<'tcx>,
    pub queries: &'tcx Queries<'tcx>,
}

Fields

tcx: TyCtxt<'tcx>

queries: &'tcx Queries<'tcx>

Implementations

impl<'tcx> QueryCtxt<'tcx>

pub fn from_tcx(tcx: TyCtxt<'tcx>) -> Self

pub(crate) fn on_disk_cache(self) -> Option<&'tcx OnDiskCache<'tcx>>

pub(crate) fn encode_query_results(
    self,
    encoder: &mut CacheEncoder<'_, 'tcx>,
    query_result_index: &mut Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>
)

pub fn try_print_query_stack(
    self,
    query: Option<QueryJobId>,
    handler: &Handler,
    num_frames: Option<usize>
) -> usize

Trait Implementations

impl<'tcx> Clone for QueryCtxt<'tcx>

fn clone(&self) -> QueryCtxt<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Deref for QueryCtxt<'tcx>

type Target = TyCtxt<'tcx>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'tcx> HasDepContext for QueryCtxt<'tcx>

type DepKind = DepKind

type DepContext = TyCtxt<'tcx>

fn dep_context(&self) -> &Self::DepContext

impl QueryContext for QueryCtxt<'_>

fn start_query<R>(
    &self,
    token: QueryJobId,
    depth_limit: bool,
    diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
    compute: impl FnOnce() -> R
) -> R

Executes a job by changing the ImplicitCtxt to point to the new query job while it executes. It returns the diagnostics captured during execution and the actual result.

fn next_job_id(&self) -> QueryJobId

fn current_query_job(&self) -> Option<QueryJobId>

Get the query information from the TLS context.

fn try_collect_active_jobs(&self) -> Option<QueryMap>

fn load_side_effects(
    &self,
    prev_dep_node_index: SerializedDepNodeIndex
) -> QuerySideEffects

Load side effects associated to the node in the previous session.

fn store_side_effects(
    &self,
    dep_node_index: DepNodeIndex,
    side_effects: QuerySideEffects
)

Register diagnostics for the given node, for use in next session.

fn store_side_effects_for_anon_node(
    &self,
    dep_node_index: DepNodeIndex,
    side_effects: QuerySideEffects
)

Register diagnostics for the given node, for use in next session.

fn depth_limit_error(&self, job: QueryJobId)

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for adt_def<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, AdtDef<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for adt_destructor<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<Destructor>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for adt_drop_tys<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Result<&'tcx List<Ty<'tcx>>, AlwaysRequiresDrop>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for adt_dtorck_constraint<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Result<&'tcx DropckConstraint<'tcx>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for adt_significant_drop_tys<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Result<&'tcx List<Ty<'tcx>>, AlwaysRequiresDrop>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for adt_sized_constraint<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [Ty<'tcx>]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for all_diagnostic_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), DiagnosticItems>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for all_local_trait_impls<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx IndexMap<DefId, Vec<LocalDefId, Global>, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for allocator_kind<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), Option<AllocatorKind>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for analysis<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), Result<(), ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for asm_target_features<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx HashSet<Symbol, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for associated_item<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, AssocItem>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for associated_item_def_ids<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [DefId]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for associated_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, AssocItems<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for assumed_wf_types<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx List<Ty<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for asyncness<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, IsAsync>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for backend_optimization_level<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), OptLevel>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_expectations<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Option<Symbol>, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_liveness<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_match<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_attrs<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_const_bodies<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_deathness<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_impl_wf<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_item_types<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_loops<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_naked_functions<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_privacy<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_type_wf<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_mod_unstable_api_usage<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_private_in_public<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for check_well_formed<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for codegen_fn_attrs<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, CodegenFnAttrs>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for codegen_select_candidate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(ParamEnv<'tcx>, Binder<'tcx, TraitRef<'tcx>>), Result<&'tcx ImplSource<'tcx, ()>, CodegenObligationError>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for codegen_unit<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Symbol, &'tcx CodegenUnit<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for codegened_and_inlined_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx HashSet<DefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for coerce_unsized_info<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, CoerceUnsizedInfo>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for coherent_trait<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for collect_and_partition_mono_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), (&'tcx HashSet<DefId, BuildHasherDefault<FxHasher>>, &'tcx [CodegenUnit<'tcx>])>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for collect_mod_item_types<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for collect_trait_impl_trait_tys<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Result<&'tcx HashMap<DefId, Ty<'tcx>, BuildHasherDefault<FxHasher>>, ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for compare_assoc_const_impl_item_with_trait_item<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), Result<(), ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for conservative_is_privately_uninhabited<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for const_caller_location<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Symbol, u32, u32), ConstValue<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for const_param_default<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Const<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for constness<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Constness>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for coverageinfo<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, InstanceDef<'tcx>, CoverageInfo>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for covered_code_regions<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, Vec<&'tcx CodeRegion, Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_extern_paths<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, Vec<PathBuf, Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_hash<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, Svh>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_host_hash<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, Option<Svh>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_incoherent_impls<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(CrateNum, SimplifiedTypeGen<DefId>), &'tcx [DefId]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_inherent_impls<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), CrateInherentImpls>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_inherent_impls_overlap_check<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_name<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, Symbol>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crate_variances<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), CrateVariancesMap<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for crates<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx [CrateNum]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for debugger_visualizers<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, Vec<DebuggerVisualizerFile, Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for deduced_param_attrs<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [DeducedParamAttrs]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for def_ident_span<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<Span>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for def_span<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Span>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for defined_lang_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, &'tcx [(DefId, LangItem)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for defined_lib_features<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, &'tcx [(Symbol, Option<Symbol>)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for dep_kind<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, CrateDepKind>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for dependency_formats<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), Rc<Vec<(CrateType, Vec<Linkage, Global>), Global>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for deref_mir_constant<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, ConstantKind<'tcx>>, ConstantKind<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for destructure_const<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Const<'tcx>, DestructuredConst<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for diagnostic_hir_wf_check<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (Predicate<'tcx>, WellFormedLoc), Option<ObligationCause<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for diagnostic_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, DiagnosticItems>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for diagnostic_only_typeck<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, &'tcx TypeckResults<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for dropck_outlives<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Ty<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for dylib_dependency_formats<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, &'tcx [(CrateNum, LinkagePreference)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for effective_visibilities<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx EffectiveVisibilities>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for entry_fn<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), Option<(DefId, EntryFnType)>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for erase_regions_ty<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Ty<'tcx>, Ty<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for eval_to_allocation_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, GlobalId<'tcx>>, Result<ConstAlloc<'tcx>, ErrorHandled>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for eval_to_const_value_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, GlobalId<'tcx>>, Result<ConstValue<'tcx>, ErrorHandled>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for eval_to_valtree<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, GlobalId<'tcx>>, Result<Option<ValTree<'tcx>>, ErrorHandled>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for evaluate_goal<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ChalkEnvironmentAndGoal<'tcx>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for evaluate_obligation<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Predicate<'tcx>>>, Result<EvaluationResult, OverflowError>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for explicit_item_bounds<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [(Predicate<'tcx>, Span)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for explicit_predicates_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for expn_that_defined<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ExpnId>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for exported_symbols<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for extern_crate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<&'tcx ExternCrate>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for extern_mod_stmt_cnum<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, Option<CrateNum>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for extra_filename<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, String>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for features_query<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx Features>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for fn_abi_of_fn_ptr<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, (Binder<'tcx, FnSig<'tcx>>, &'tcx List<Ty<'tcx>>)>, Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, FnAbiError<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for fn_abi_of_instance<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, (Instance<'tcx>, &'tcx List<Ty<'tcx>>)>, Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, FnAbiError<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for fn_arg_names<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [Ident]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for fn_sig<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Binder<'tcx, FnSig<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for foreign_modules<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, HashMap<DefId, ForeignModule, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for generator_diagnostic_data<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, Option<GeneratorDiagnosticData<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for generator_kind<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<GeneratorKind>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for generics_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, Generics>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for get_lang_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), LanguageItems>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for global_backend_features<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), Vec<String, Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for has_ffi_unwind_calls<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for has_global_allocator<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for has_panic_handler<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for has_significant_drop_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for has_structural_eq_impls<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Ty<'tcx>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for has_typeck_results<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for hir_attrs<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, &'tcx AttributeMap<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for hir_crate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), Crate<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for hir_crate_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), ModuleItems>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for hir_module_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, LocalDefId, ModuleItems>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for hir_owner<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, Option<Owner<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for hir_owner_nodes<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, MaybeOwner<&'tcx OwnerNodes<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for hir_owner_parent<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, HirId>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for impl_defaultness<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Defaultness>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for impl_item_implementor_ids<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, HashMap<DefId, DefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for impl_parent<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<DefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for impl_polarity<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ImplPolarity>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for impl_trait_ref<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<TraitRef<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for implementations_of_trait<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(CrateNum, DefId), &'tcx [(DefId, Option<SimplifiedTypeGen<DefId>>)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for implied_outlives_bounds<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Ty<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Vec<OutlivesBound<'tcx>, Global>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for in_scope_traits_map<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, Option<&'tcx HashMap<ItemLocalId, Box<[TraitCandidate], Global>, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for incoherent_impls<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<SimplifiedTypeGen<DefId>, &'tcx [DefId]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for inferred_outlives_crate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), CratePredicatesMap<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for inferred_outlives_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [(Predicate<'tcx>, Span)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for inhabited_predicate_adt<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, InhabitedPredicate<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for inhabited_predicate_type<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Ty<'tcx>, InhabitedPredicate<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for inherent_impls<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [DefId]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for instance_def_size_estimate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<InstanceDef<'tcx>, usize>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_codegened_item<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_compiler_builtins<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_copy_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_ctfe_mir_available<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_doc_hidden<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_doc_notable_trait<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_foreign_item<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_freeze_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_impossible_method<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, DefId), bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_intrinsic<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_late_bound_map<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, Option<&'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_mir_available<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_no_builtins<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_panic_runtime<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_private_dep<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_profiler_runtime<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_promotable_const_fn<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_reachable_non_generic<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_sized_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_unpin_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for is_unreachable_local_definition<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for issue33140_self_ty<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<Ty<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for item_attrs<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [Attribute]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for item_bounds<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx List<Predicate<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for late_bound_vars_map<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, Option<&'tcx HashMap<ItemLocalId, Vec<BoundVariableKind, Global>, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for layout_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, Result<TyAndLayout<'tcx, Ty<'tcx>>, LayoutError<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lib_features<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), LibFeatures>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for limits<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), Limits>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lint_expectations<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), Vec<(LintExpectationId, LintExpectation), Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lint_mod<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lit_to_const<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LitToConstInput<'tcx>, Result<Const<'tcx>, LitToConstError>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lit_to_mir_constant<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LitToConstInput<'tcx>, Result<ConstantKind<'tcx>, LitToConstError>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for live_symbols_and_ignored_derived_traits<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), (HashSet<LocalDefId, BuildHasherDefault<FxHasher>>, HashMap<LocalDefId, Vec<(DefId, DefId), Global>, BuildHasherDefault<FxHasher>>)>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for local_def_id_to_hir_id<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, HirId>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lookup_const_stability<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<ConstStability>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lookup_default_body_stability<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<DefaultBodyStability>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lookup_deprecation_entry<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<DeprecationEntry>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for lookup_stability<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<Stability>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for maybe_unused_extern_crates<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx [(LocalDefId, Span)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for maybe_unused_trait_imports<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for method_autoderef_steps<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Ty<'tcx>>>, MethodAutoderefStepsResult<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_borrowck<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, &'tcx BorrowCheckResult<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_borrowck_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx BorrowCheckResult<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_built<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, &'tcx Steal<Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_callgraph_reachable<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Instance<'tcx>, LocalDefId), bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_const<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, &'tcx Steal<Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_const_qualif<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ConstQualifs>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_const_qualif_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), ConstQualifs>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_drops_elaborated_and_const_checked<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, &'tcx Steal<Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_for_ctfe<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_for_ctfe_of_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_inliner_callees<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<InstanceDef<'tcx>, &'tcx [(DefId, &'tcx List<GenericArg<'tcx>>)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_keys<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_promoted<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, (&'tcx Steal<Body<'tcx>>, &'tcx Steal<IndexVec<Promoted, Body<'tcx>>>)>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for mir_shims<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, InstanceDef<'tcx>, Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for missing_extern_crate_item<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for missing_lang_items<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, &'tcx [LangItem]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for module_children<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [ModChild]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for module_reexports<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, Option<&'tcx [ModChild]>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for named_region_map<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<OwnerId, Option<&'tcx HashMap<ItemLocalId, Region, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for names_imported_by_glob_use<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, &'tcx HashSet<Symbol, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for native_libraries<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, Vec<NativeLib, Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for native_library<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<&'tcx NativeLib>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for needs_drop_raw<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for normalize_opaque_types<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<&'tcx List<Predicate<'tcx>>, &'tcx List<Predicate<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for normalize_projection_ty<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, ProjectionTy<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, NormalizationResult<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for object_lifetime_default<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ObjectLifetimeDefault>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for object_safety_violations<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [ObjectSafetyViolation]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for opt_const_param_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, Option<DefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for opt_def_kind<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<DefKind>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for optimized_mir<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for orphan_check_impl<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, Result<(), ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for output_filenames<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx Arc<OutputFilenames>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for own_existential_vtable_entries<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [DefId]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for panic_in_drop_strategy<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, PanicStrategy>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for param_env<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ParamEnv<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for param_env_reveal_all_normalized<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ParamEnv<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for params_in_repr<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, BitSet<u32>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for parent_module_from_def_id<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, LocalDefId>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for permits_uninit_init<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<TyAndLayout<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for permits_zero_init<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<TyAndLayout<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for postorder_cnums<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx [CrateNum]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for predicates_defined_on<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for predicates_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for proc_macro_decls_static<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), Option<LocalDefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for promoted_mir<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx IndexVec<Promoted, Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for promoted_mir_of_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx IndexVec<Promoted, Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for reachable_non_generics<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, HashMap<DefId, SymbolExportInfo, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for reachable_set<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashSet<LocalDefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for region_scope_tree<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx ScopeTree>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for rendered_const<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, String>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for representability<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, Representability>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for representability_adt_ty<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Ty<'tcx>, Representability>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for required_panic_strategy<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, Option<PanicStrategy>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for resolutions<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx ResolverGlobalCtxt>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for resolve_instance<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, (DefId, &'tcx List<GenericArg<'tcx>>)>, Result<Option<Instance<'tcx>>, ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for resolve_instance_of_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, (LocalDefId, DefId, &'tcx List<GenericArg<'tcx>>)>, Result<Option<Instance<'tcx>>, ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for resolve_lifetimes<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, LocalDefId, ResolveLifetimes>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for resolve_lifetimes_trait_definition<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, LocalDefId, ResolveLifetimes>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for resolver_for_lowering<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx Steal<ResolverAstLowering>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for shallow_lint_levels_on<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, OwnerId, ShallowLintLevelMap>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for should_inherit_track_caller<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for source_span<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, Span>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for specialization_graph_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, Graph>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for specializes<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, DefId), bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for stability_implications<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, HashMap<Symbol, Symbol, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for stability_index<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), Index>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for subst_and_check_impossible_predicates<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, &'tcx List<GenericArg<'tcx>>), bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for super_predicates_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for super_predicates_that_define_assoc_type<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, Option<Ident>), GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for supported_target_features<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, HashMap<String, Option<Symbol>, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for symbol_mangling_version<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, SymbolManglingVersion>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for symbol_name<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Instance<'tcx>, SymbolName<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for symbols_for_closure_captures<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (LocalDefId, LocalDefId), Vec<Symbol, Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for thir_abstract_const<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Result<Option<&'tcx [Node<'tcx>]>, ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for thir_abstract_const_of_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), Result<Option<&'tcx [Node<'tcx>]>, ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for thir_body<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, Result<(&'tcx Steal<Thir<'tcx>>, ExprId), ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for thir_check_unsafety<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for thir_check_unsafety_for_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for thir_tree<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, WithOptConstParam<LocalDefId>, String>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for trait_def<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, TraitDef>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for trait_explicit_predicates_and_bounds<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for trait_impls_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, TraitImpls>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for traits_in_crate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<CrateNum, &'tcx [DefId]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for trigger_delay_span_bug<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for trimmed_def_paths<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashMap<DefId, Symbol, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for try_destructure_mir_constant<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, ConstantKind<'tcx>>, Option<DestructuredConstant<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for try_normalize_generic_arg_after_erasing_regions<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, GenericArg<'tcx>>, Result<GenericArg<'tcx>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for try_unify_abstract_consts<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, (UnevaluatedConst<'tcx>, UnevaluatedConst<'tcx>)>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Ty<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_ascribe_user_type<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, AscribeUserType<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_eq<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Eq<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_normalize_fn_sig<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<FnSig<'tcx>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, FnSig<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_normalize_poly_fn_sig<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Binder<'tcx, FnSig<'tcx>>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Binder<'tcx, FnSig<'tcx>>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_normalize_predicate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Predicate<'tcx>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Predicate<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_normalize_ty<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Ty<'tcx>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_prove_predicate<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, ProvePredicate<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_op_subtype<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Subtype<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for type_param_predicates<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, LocalDefId, Ident), GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for typeck<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, &'tcx TypeckResults<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for typeck_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx TypeckResults<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for typeck_item_bodies<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for unsafe_derive_on_repr_packed<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for unsafety_check_result<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, &'tcx UnsafetyCheckResult>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for unsafety_check_result_for_const_arg<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx UnsafetyCheckResult>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for unused_generic_params<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<InstanceDef<'tcx>, FiniteBitSet<u32>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for upstream_drop_glue_for<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<&'tcx List<GenericArg<'tcx>>, Option<CrateNum>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for upstream_monomorphizations<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashMap<DefId, HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for upstream_monomorphizations_for<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, Option<&'tcx HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for upvars_mentioned<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<&'tcx IndexMap<HirId, Upvar, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for used_crate_source<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, Rc<CrateSource>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for used_trait_imports<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<LocalDefId, &'tcx UnordSet<LocalDefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for valtree_to_const_val<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Ty<'tcx>, ValTree<'tcx>), ConstValue<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for variances_of<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [Variance]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for visibility<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Visibility<DefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for visible_parent_map<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashMap<DefId, DefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for vtable_allocation<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Ty<'tcx>, Option<Binder<'tcx, ExistentialTraitRef<'tcx>>>), AllocId>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for vtable_entries<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Binder<'tcx, TraitRef<'tcx>>, &'tcx [VtblEntry<'tcx>]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for vtable_trait_upcasting_coercion_new_vptr_slot<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Ty<'tcx>, Ty<'tcx>), Option<usize>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for wasm_import_module_map<'tcx>

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, CrateNum, HashMap<DefId, String, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> Copy for QueryCtxt<'tcx>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes