Struct rustc_query_impl::plumbing::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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<DefId, AdtSizedConstraint<'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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 codegen_fn_attrs<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 conservative_is_privately_uninhabited<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, param: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 def_ident_span<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<CrateNum, &'tcx [(DefId, 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 defined_lib_features<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 entry_fn<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, cnum: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<LocalDefId, &'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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<LocalDefId, 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<LocalDefId, 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 impl_defaultness<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, impl_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, impl_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<LocalDefId, 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 inherent_impls<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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_dllimport_foreign_item<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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_statically_included_foreign_item<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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_unpin_raw<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<LocalDefId, 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<LocalDefId, 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 native_library_kind<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

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

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

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

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<Binder<'tcx, ExistentialTraitRef<'tcx>>, &'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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 parent_module_from_def_id<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 privacy_access_levels<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<(), &'tcx AccessLevels<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 proc_macro_decls_static<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 required_panic_strategy<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

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

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

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

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = ArenaCache<'tcx, HirId, 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, trait_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<ParamEnvAnd<'tcx, ConstantKind<'tcx>>, Option<DestructuredMirConstant<'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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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_normalize_mir_const_after_erasing_regions<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<ParamEnvAnd<'tcx, ConstantKind<'tcx>>, Result<ConstantKind<'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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<ParamEnvAnd<'tcx, (Unevaluated<'tcx, ()>, Unevaluated<'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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 type_uninhabited_from<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, DefIdForest<'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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: 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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

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

type Cache = DefaultCache<LocalDefId, &'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 valtree_to_const_val<'tcx>

fn describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, def_id: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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 describe(tcx: QueryCtxt<'tcx>, key: Self::Key) -> String

fn cache_on_disk(_: TyCtxt<'tcx>, _: &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