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<'tcx> QueryConfig<QueryCtxt<'tcx>> for adt_def<'tcx>

type Key = DefId

type Value = AdtDef<'tcx>

type Stored = AdtDef<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Option<Destructor>

type Stored = Option<Destructor>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Result<&'tcx List<Ty<'tcx>>, AlwaysRequiresDrop>

type Stored = Result<&'tcx List<Ty<'tcx>>, AlwaysRequiresDrop>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Result<&'tcx DropckConstraint<'tcx>, NoSolution>

type Stored = Result<&'tcx DropckConstraint<'tcx>, NoSolution>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Result<&'tcx List<Ty<'tcx>>, AlwaysRequiresDrop>

type Stored = Result<&'tcx List<Ty<'tcx>>, AlwaysRequiresDrop>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = &'tcx [Ty<'tcx>]

type Stored = &'tcx [Ty<'tcx>]

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = DiagnosticItems

type Stored = &'tcx DiagnosticItems

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = &'tcx IndexMap<DefId, Vec<LocalDefId, Global>, BuildHasherDefault<FxHasher>>

type Stored = &'tcx IndexMap<DefId, Vec<LocalDefId, Global>, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for alloc_error_handler_kind<'tcx>

type Key = ()

type Value = Option<AllocatorKind>

type Stored = Option<AllocatorKind>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = Option<AllocatorKind>

type Stored = Option<AllocatorKind>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = Result<(), ErrorGuaranteed>

type Stored = Result<(), ErrorGuaranteed>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = &'tcx HashSet<Symbol, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashSet<Symbol, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = AssocItem

type Stored = &'tcx AssocItem

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = &'tcx [DefId]

type Stored = &'tcx [DefId]

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = AssocItems<'tcx>

type Stored = &'tcx AssocItems<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = &'tcx List<Ty<'tcx>>

type Stored = &'tcx List<Ty<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = IsAsync

type Stored = IsAsync

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, IsAsync>

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

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

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

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

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

type Key = ()

type Value = OptLevel

type Stored = OptLevel

const NAME: &'static str = _

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

type Cache = DefaultCache<(), OptLevel>

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

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

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

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

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

type Key = Option<Symbol>

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, ()>

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

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

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

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

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

type Key = DefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, ()>

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

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

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

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

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

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_const_bodies<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_deathness<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_impl_wf<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_item_types<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_loops<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_naked_functions<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_privacy<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_type_wf<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_mod_unstable_api_usage<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for check_private_in_public<'tcx>

type Key = ()

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = DefaultCache<(), ()>

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

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

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

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

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

type Key = OwnerId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<OwnerId, ()>

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

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

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

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

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

type Key = DefId

type Value = CodegenFnAttrs

type Stored = &'tcx CodegenFnAttrs

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = (ParamEnv<'tcx>, Binder<'tcx, TraitRef<'tcx>>)

type Value = Result<&'tcx ImplSource<'tcx, ()>, CodegenObligationError>

type Stored = Result<&'tcx ImplSource<'tcx, ()>, CodegenObligationError>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = Symbol

type Value = &'tcx CodegenUnit<'tcx>

type Stored = &'tcx CodegenUnit<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = &'tcx HashSet<DefId, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashSet<DefId, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = CoerceUnsizedInfo

type Stored = CoerceUnsizedInfo

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, CoerceUnsizedInfo>

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

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

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

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

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

type Key = DefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, ()>

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

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

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

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

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

type Key = ()

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

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

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for collect_trait_impl_trait_tys<'tcx>

type Key = DefId

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

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

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = (LocalDefId, DefId)

type Value = Result<(), ErrorGuaranteed>

type Stored = Result<(), ErrorGuaranteed>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = (Symbol, u32, u32)

type Value = ConstValue<'tcx>

type Stored = ConstValue<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Const<'tcx>

type Stored = Const<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Constness

type Stored = Constness

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, Constness>

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

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

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

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

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

type Key = InstanceDef<'tcx>

type Value = CoverageInfo

type Stored = &'tcx CoverageInfo

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Vec<&'tcx CodeRegion, Global>

type Stored = &'tcx Vec<&'tcx CodeRegion, Global>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = CrateNum

type Value = Vec<PathBuf, Global>

type Stored = &'tcx Vec<PathBuf, Global>

const NAME: &'static str = _

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

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for crate_hash<'tcx>

type Key = CrateNum

type Value = Svh

type Stored = Svh

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for crate_host_hash<'tcx>

type Key = CrateNum

type Value = Option<Svh>

type Stored = Option<Svh>

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for crate_incoherent_impls<'tcx>

type Key = (CrateNum, SimplifiedType)

type Value = &'tcx [DefId]

type Stored = &'tcx [DefId]

const NAME: &'static str = _

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

type Cache = DefaultCache<(CrateNum, SimplifiedType), &'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> QueryConfig<QueryCtxt<'tcx>> for crate_inherent_impls<'tcx>

type Key = ()

type Value = CrateInherentImpls

type Stored = &'tcx CrateInherentImpls

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = DefaultCache<(), ()>

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

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

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

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

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

type Key = CrateNum

type Value = Symbol

type Stored = Symbol

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for crate_variances<'tcx>

type Key = ()

type Value = CrateVariancesMap<'tcx>

type Stored = &'tcx CrateVariancesMap<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = &'tcx [CrateNum]

type Stored = &'tcx [CrateNum]

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = CrateNum

type Value = Vec<DebuggerVisualizerFile, Global>

type Stored = &'tcx Vec<DebuggerVisualizerFile, Global>

const NAME: &'static str = _

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

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for deduced_param_attrs<'tcx>

type Key = DefId

type Value = &'tcx [DeducedParamAttrs]

type Stored = &'tcx [DeducedParamAttrs]

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Option<Span>

type Stored = Option<Span>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Span

type Stored = Span

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, Span>

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

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

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

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

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

type Key = CrateNum

type Value = &'tcx [(DefId, LangItem)]

type Stored = &'tcx [(DefId, LangItem)]

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = CrateNum

type Value = &'tcx [(Symbol, Option<Symbol>)]

type Stored = &'tcx [(Symbol, Option<Symbol>)]

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for dep_kind<'tcx>

type Key = CrateNum

type Value = CrateDepKind

type Stored = CrateDepKind

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for dependency_formats<'tcx>

type Key = ()

type Value = Rc<Vec<(CrateType, Vec<Linkage, Global>), Global>>

type Stored = &'tcx Rc<Vec<(CrateType, Vec<Linkage, Global>), Global>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ParamEnvAnd<'tcx, ConstantKind<'tcx>>

type Value = ConstantKind<'tcx>

type Stored = ConstantKind<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = Const<'tcx>

type Value = DestructuredConst<'tcx>

type Stored = DestructuredConst<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = (Predicate<'tcx>, WellFormedLoc)

type Value = Option<ObligationCause<'tcx>>

type Stored = &'tcx Option<ObligationCause<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = CrateNum

type Value = DiagnosticItems

type Stored = &'tcx DiagnosticItems

const NAME: &'static str = _

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

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for diagnostic_only_typeck<'tcx>

type Key = LocalDefId

type Value = &'tcx TypeckResults<'tcx>

type Stored = &'tcx TypeckResults<'tcx>

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for dropck_outlives<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Ty<'tcx>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>, NoSolution>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = CrateNum

type Value = &'tcx [(CrateNum, LinkagePreference)]

type Stored = &'tcx [(CrateNum, LinkagePreference)]

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for effective_visibilities<'tcx>

type Key = ()

type Value = &'tcx EffectiveVisibilities<LocalDefId>

type Stored = &'tcx EffectiveVisibilities<LocalDefId>

const NAME: &'static str = _

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

type Cache = DefaultCache<(), &'tcx EffectiveVisibilities<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> QueryConfig<QueryCtxt<'tcx>> for entry_fn<'tcx>

type Key = ()

type Value = Option<(DefId, EntryFnType)>

type Stored = Option<(DefId, EntryFnType)>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = Ty<'tcx>

type Value = Ty<'tcx>

type Stored = Ty<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ParamEnvAnd<'tcx, GlobalId<'tcx>>

type Value = Result<ConstAlloc<'tcx>, ErrorHandled>

type Stored = Result<ConstAlloc<'tcx>, ErrorHandled>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ParamEnvAnd<'tcx, GlobalId<'tcx>>

type Value = Result<ConstValue<'tcx>, ErrorHandled>

type Stored = Result<ConstValue<'tcx>, ErrorHandled>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ParamEnvAnd<'tcx, GlobalId<'tcx>>

type Value = Result<Option<ValTree<'tcx>>, ErrorHandled>

type Stored = Result<Option<ValTree<'tcx>>, ErrorHandled>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = Canonical<'tcx, ChalkEnvironmentAndGoal<'tcx>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Predicate<'tcx>>>

type Value = Result<EvaluationResult, OverflowError>

type Stored = Result<EvaluationResult, OverflowError>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = &'tcx [(Predicate<'tcx>, Span)]

type Stored = &'tcx [(Predicate<'tcx>, Span)]

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = GenericPredicates<'tcx>

type Stored = GenericPredicates<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = ExpnId

type Stored = ExpnId

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, ExpnId>

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

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

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

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

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

type Key = CrateNum

type Value = &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)]

type Stored = &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)]

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for extern_crate<'tcx>

type Key = DefId

type Value = Option<&'tcx ExternCrate>

type Stored = Option<&'tcx ExternCrate>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = LocalDefId

type Value = Option<CrateNum>

type Stored = Option<CrateNum>

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for extra_filename<'tcx>

type Key = CrateNum

type Value = String

type Stored = &'tcx String

const NAME: &'static str = _

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

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for features_query<'tcx>

type Key = ()

type Value = &'tcx Features

type Stored = &'tcx Features

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ParamEnvAnd<'tcx, (Binder<'tcx, FnSig<'tcx>>, &'tcx List<Ty<'tcx>>)>

type Value = Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, FnAbiError<'tcx>>

type Stored = Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, FnAbiError<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ParamEnvAnd<'tcx, (Instance<'tcx>, &'tcx List<Ty<'tcx>>)>

type Value = Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, FnAbiError<'tcx>>

type Stored = Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, FnAbiError<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = &'tcx [Ident]

type Stored = &'tcx [Ident]

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Binder<'tcx, FnSig<'tcx>>

type Stored = Binder<'tcx, FnSig<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = CrateNum

type Value = HashMap<DefId, ForeignModule, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<DefId, ForeignModule, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

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

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for generator_diagnostic_data<'tcx>

type Key = DefId

type Value = Option<GeneratorDiagnosticData<'tcx>>

type Stored = &'tcx Option<GeneratorDiagnosticData<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Option<GeneratorKind>

type Stored = Option<GeneratorKind>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Generics

type Stored = &'tcx Generics

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = LanguageItems

type Stored = &'tcx LanguageItems

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = Vec<String, Global>

type Stored = &'tcx Vec<String, Global>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for has_alloc_error_handler<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for has_ffi_unwind_calls<'tcx>

type Key = LocalDefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for has_global_allocator<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for has_panic_handler<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for has_significant_drop_raw<'tcx>

type Key = ParamEnvAnd<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = Ty<'tcx>

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

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

type Key = OwnerId

type Value = &'tcx AttributeMap<'tcx>

type Stored = &'tcx AttributeMap<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = Crate<'tcx>

type Stored = &'tcx Crate<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = ()

type Value = ModuleItems

type Stored = &'tcx ModuleItems

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = LocalDefId

type Value = ModuleItems

type Stored = &'tcx ModuleItems

const NAME: &'static str = _

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

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for hir_owner<'tcx>

type Key = OwnerId

type Value = Option<Owner<'tcx>>

type Stored = Option<Owner<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = OwnerId

type Value = MaybeOwner<&'tcx OwnerNodes<'tcx>>

type Stored = MaybeOwner<&'tcx OwnerNodes<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = OwnerId

type Value = HirId

type Stored = HirId

const NAME: &'static str = _

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

type Cache = VecCache<OwnerId, HirId>

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

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

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

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

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

type Key = DefId

type Value = Defaultness

type Stored = Defaultness

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, Defaultness>

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

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

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

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

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

type Key = DefId

type Value = HashMap<DefId, DefId, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<DefId, DefId, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = Option<DefId>

type Stored = Option<DefId>

const NAME: &'static str = _

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

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

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

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

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

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

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

type Key = DefId

type Value = ImplPolarity

type Stored = ImplPolarity

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, ImplPolarity>

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

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

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

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

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

type Key = DefId

type Value = Option<TraitRef<'tcx>>

type Stored = Option<TraitRef<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for implementations_of_trait<'tcx>

type Key = (CrateNum, DefId)

type Value = &'tcx [(DefId, Option<SimplifiedType>)]

type Stored = &'tcx [(DefId, Option<SimplifiedType>)]

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for implied_outlives_bounds<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Ty<'tcx>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Vec<OutlivesBound<'tcx>, Global>>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Vec<OutlivesBound<'tcx>, Global>>>, NoSolution>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for in_scope_traits_map<'tcx>

type Key = OwnerId

type Value = Option<&'tcx HashMap<ItemLocalId, Box<[TraitCandidate], Global>, BuildHasherDefault<FxHasher>>>

type Stored = Option<&'tcx HashMap<ItemLocalId, Box<[TraitCandidate], Global>, BuildHasherDefault<FxHasher>>>

const NAME: &'static str = _

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

type Cache = VecCache<OwnerId, Option<&'tcx HashMap<ItemLocalId, Box<[TraitCandidate], Global>, BuildHasherDefault<FxHasher>>>>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for incoherent_impls<'tcx>

type Key = SimplifiedType

type Value = &'tcx [DefId]

type Stored = &'tcx [DefId]

const NAME: &'static str = _

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

type Cache = DefaultCache<SimplifiedType, &'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> QueryConfig<QueryCtxt<'tcx>> for inferred_outlives_crate<'tcx>

type Key = ()

type Value = CratePredicatesMap<'tcx>

type Stored = &'tcx CratePredicatesMap<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for inferred_outlives_of<'tcx>

type Key = DefId

type Value = &'tcx [(Clause<'tcx>, Span)]

type Stored = &'tcx [(Clause<'tcx>, Span)]

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, &'tcx [(Clause<'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> QueryConfig<QueryCtxt<'tcx>> for inhabited_predicate_adt<'tcx>

type Key = DefId

type Value = InhabitedPredicate<'tcx>

type Stored = InhabitedPredicate<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for inhabited_predicate_type<'tcx>

type Key = Ty<'tcx>

type Value = InhabitedPredicate<'tcx>

type Stored = InhabitedPredicate<'tcx>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for inherent_impls<'tcx>

type Key = DefId

type Value = &'tcx [DefId]

type Stored = &'tcx [DefId]

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for instance_def_size_estimate<'tcx>

type Key = InstanceDef<'tcx>

type Value = usize

type Stored = usize

const NAME: &'static str = _

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

type Cache = DefaultCache<InstanceDef<'tcx>, usize>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_codegened_item<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_compiler_builtins<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for is_copy_raw<'tcx>

type Key = ParamEnvAnd<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_ctfe_mir_available<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_doc_hidden<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_doc_notable_trait<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_foreign_item<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_freeze_raw<'tcx>

type Key = ParamEnvAnd<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_impossible_method<'tcx>

type Key = (DefId, DefId)

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<(DefId, DefId), bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_intrinsic<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_late_bound_map<'tcx>

type Key = LocalDefId

type Value = Option<&'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>>

type Stored = Option<&'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>>

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for is_mir_available<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_no_builtins<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for is_panic_runtime<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for is_private_dep<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for is_profiler_runtime<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for is_promotable_const_fn<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_reachable_non_generic<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = DefaultCache<DefId, bool>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_sized_raw<'tcx>

type Key = ParamEnvAnd<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_unpin_raw<'tcx>

type Key = ParamEnvAnd<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for is_unreachable_local_definition<'tcx>

type Key = LocalDefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for issue33140_self_ty<'tcx>

type Key = DefId

type Value = Option<Ty<'tcx>>

type Stored = Option<Ty<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for item_attrs<'tcx>

type Key = DefId

type Value = &'tcx [Attribute]

type Stored = &'tcx [Attribute]

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for item_bounds<'tcx>

type Key = DefId

type Value = &'tcx List<Predicate<'tcx>>

type Stored = &'tcx List<Predicate<'tcx>>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for late_bound_vars_map<'tcx>

type Key = OwnerId

type Value = Option<&'tcx HashMap<ItemLocalId, Vec<BoundVariableKind, Global>, BuildHasherDefault<FxHasher>>>

type Stored = Option<&'tcx HashMap<ItemLocalId, Vec<BoundVariableKind, Global>, BuildHasherDefault<FxHasher>>>

const NAME: &'static str = _

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

type Cache = VecCache<OwnerId, Option<&'tcx HashMap<ItemLocalId, Vec<BoundVariableKind, Global>, BuildHasherDefault<FxHasher>>>>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for layout_of<'tcx>

type Key = ParamEnvAnd<'tcx, Ty<'tcx>>

type Value = Result<TyAndLayout<'tcx, Ty<'tcx>>, LayoutError<'tcx>>

type Stored = Result<TyAndLayout<'tcx, Ty<'tcx>>, LayoutError<'tcx>>

const NAME: &'static str = _

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

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, Result<TyAndLayout<'tcx, Ty<'tcx>>, LayoutError<'tcx>>>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for lib_features<'tcx>

type Key = ()

type Value = LibFeatures

type Stored = &'tcx LibFeatures

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for limits<'tcx>

type Key = ()

type Value = Limits

type Stored = Limits

const NAME: &'static str = _

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

type Cache = DefaultCache<(), Limits>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for lint_expectations<'tcx>

type Key = ()

type Value = Vec<(LintExpectationId, LintExpectation), Global>

type Stored = &'tcx Vec<(LintExpectationId, LintExpectation), Global>

const NAME: &'static str = _

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

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

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for lint_mod<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

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

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for lit_to_const<'tcx>

type Key = LitToConstInput<'tcx>

type Value = Result<Const<'tcx>, LitToConstError>

type Stored = Result<Const<'tcx>, LitToConstError>

const NAME: &'static str = _

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

type Cache = DefaultCache<LitToConstInput<'tcx>, Result<Const<'tcx>, LitToConstError>>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for lit_to_mir_constant<'tcx>

type Key = LitToConstInput<'tcx>

type Value = Result<ConstantKind<'tcx>, LitToConstError>

type Stored = Result<ConstantKind<'tcx>, LitToConstError>

const NAME: &'static str = _

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

type Cache = DefaultCache<LitToConstInput<'tcx>, Result<ConstantKind<'tcx>, LitToConstError>>

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

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

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

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

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for live_symbols_and_ignored_derived_traits<'tcx>

type Key = ()

type Value = (HashSet<LocalDefId, BuildHasherDefault<FxHasher>>, HashMap<LocalDefId, Vec<(DefId, DefId), Global>, BuildHasherDefault<FxHasher>>)

type Stored = &'tcx (HashSet<LocalDefId, BuildHasherDefault<FxHasher>>, HashMap<LocalDefId, Vec<(DefId, DefId), Global>, BuildHasherDefault<FxHasher>>)

const NAME: &'static str = _

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

type Cache = ArenaCache<'tcx, (), (HashSet<LocalDefId, BuildHasherDefault<FxHasher>>, HashMap<LocalDefId, Vec<(DefId, DefId), Global>, BuildHasherDefault<FxHasher>>)>

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

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

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for local_def_id_to_hir_id<'tcx>

type Key = LocalDefId

type Value = HirId

type Stored = HirId

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for lookup_const_stability<'tcx>

type Key = DefId

type Value = Option<ConstStability>

type Stored = Option<ConstStability>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<ConstStability>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for lookup_default_body_stability<'tcx>

type Key = DefId

type Value = Option<DefaultBodyStability>

type Stored = Option<DefaultBodyStability>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<DefaultBodyStability>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for lookup_deprecation_entry<'tcx>

type Key = DefId

type Value = Option<DeprecationEntry>

type Stored = Option<DeprecationEntry>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<DeprecationEntry>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for lookup_stability<'tcx>

type Key = DefId

type Value = Option<Stability>

type Stored = Option<Stability>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<Stability>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for maybe_unused_extern_crates<'tcx>

type Key = ()

type Value = &'tcx [(LocalDefId, Span)]

type Stored = &'tcx [(LocalDefId, Span)]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx [(LocalDefId, Span)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for maybe_unused_trait_imports<'tcx>

type Key = ()

type Value = &'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>

type Stored = &'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for method_autoderef_steps<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Ty<'tcx>>>

type Value = MethodAutoderefStepsResult<'tcx>

type Stored = MethodAutoderefStepsResult<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Ty<'tcx>>>, MethodAutoderefStepsResult<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_borrowck<'tcx>

type Key = LocalDefId

type Value = &'tcx BorrowCheckResult<'tcx>

type Stored = &'tcx BorrowCheckResult<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for mir_borrowck_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = &'tcx BorrowCheckResult<'tcx>

type Stored = &'tcx BorrowCheckResult<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx BorrowCheckResult<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_built<'tcx>

type Key = WithOptConstParam<LocalDefId>

type Value = &'tcx Steal<Body<'tcx>>

type Stored = &'tcx Steal<Body<'tcx>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, &'tcx Steal<Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_callgraph_reachable<'tcx>

type Key = (Instance<'tcx>, LocalDefId)

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Instance<'tcx>, LocalDefId), bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_const<'tcx>

type Key = WithOptConstParam<LocalDefId>

type Value = &'tcx Steal<Body<'tcx>>

type Stored = &'tcx Steal<Body<'tcx>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, &'tcx Steal<Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_const_qualif<'tcx>

type Key = DefId

type Value = ConstQualifs

type Stored = ConstQualifs

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ConstQualifs>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_const_qualif_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = ConstQualifs

type Stored = ConstQualifs

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), ConstQualifs>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_drops_elaborated_and_const_checked<'tcx>

type Key = WithOptConstParam<LocalDefId>

type Value = &'tcx Steal<Body<'tcx>>

type Stored = &'tcx Steal<Body<'tcx>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, &'tcx Steal<Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_for_ctfe<'tcx>

type Key = DefId

type Value = &'tcx Body<'tcx>

type Stored = &'tcx Body<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_for_ctfe_of_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = &'tcx Body<'tcx>

type Stored = &'tcx Body<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_inliner_callees<'tcx>

type Key = InstanceDef<'tcx>

type Value = &'tcx [(DefId, &'tcx List<GenericArg<'tcx>>)]

type Stored = &'tcx [(DefId, &'tcx List<GenericArg<'tcx>>)]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<InstanceDef<'tcx>, &'tcx [(DefId, &'tcx List<GenericArg<'tcx>>)]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_keys<'tcx>

type Key = ()

type Value = IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>

type Stored = &'tcx IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), IndexSet<LocalDefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_promoted<'tcx>

type Key = WithOptConstParam<LocalDefId>

type Value = (&'tcx Steal<Body<'tcx>>, &'tcx Steal<IndexVec<Promoted, Body<'tcx>>>)

type Stored = (&'tcx Steal<Body<'tcx>>, &'tcx Steal<IndexVec<Promoted, Body<'tcx>>>)

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, (&'tcx Steal<Body<'tcx>>, &'tcx Steal<IndexVec<Promoted, Body<'tcx>>>)>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for mir_shims<'tcx>

type Key = InstanceDef<'tcx>

type Value = Body<'tcx>

type Stored = &'tcx Body<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, InstanceDef<'tcx>, Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for missing_extern_crate_item<'tcx>

type Key = CrateNum

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for missing_lang_items<'tcx>

type Key = CrateNum

type Value = &'tcx [LangItem]

type Stored = &'tcx [LangItem]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for module_children<'tcx>

type Key = DefId

type Value = &'tcx [ModChild]

type Stored = &'tcx [ModChild]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [ModChild]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for module_reexports<'tcx>

type Key = LocalDefId

type Value = Option<&'tcx [ModChild]>

type Stored = Option<&'tcx [ModChild]>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for named_region_map<'tcx>

type Key = OwnerId

type Value = Option<&'tcx HashMap<ItemLocalId, Region, BuildHasherDefault<FxHasher>>>

type Stored = Option<&'tcx HashMap<ItemLocalId, Region, BuildHasherDefault<FxHasher>>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<OwnerId, Option<&'tcx HashMap<ItemLocalId, Region, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for names_imported_by_glob_use<'tcx>

type Key = LocalDefId

type Value = &'tcx HashSet<Symbol, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashSet<Symbol, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for native_libraries<'tcx>

type Key = CrateNum

type Value = Vec<NativeLib, Global>

type Stored = &'tcx Vec<NativeLib, Global>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for native_library<'tcx>

type Key = DefId

type Value = Option<&'tcx NativeLib>

type Stored = Option<&'tcx NativeLib>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<&'tcx NativeLib>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for needs_drop_raw<'tcx>

type Key = ParamEnvAnd<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for normalize_projection_ty<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, AliasTy<'tcx>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, NormalizationResult<'tcx>>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, NormalizationResult<'tcx>>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, AliasTy<'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> QueryConfig<QueryCtxt<'tcx>> for object_lifetime_default<'tcx>

type Key = DefId

type Value = ObjectLifetimeDefault

type Stored = ObjectLifetimeDefault

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ObjectLifetimeDefault>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for object_safety_violations<'tcx>

type Key = DefId

type Value = &'tcx [ObjectSafetyViolation]

type Stored = &'tcx [ObjectSafetyViolation]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [ObjectSafetyViolation]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for opt_const_param_of<'tcx>

type Key = LocalDefId

type Value = Option<DefId>

type Stored = Option<DefId>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for opt_def_kind<'tcx>

type Key = DefId

type Value = Option<DefKind>

type Stored = Option<DefKind>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<DefKind>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for optimized_mir<'tcx>

type Key = DefId

type Value = &'tcx Body<'tcx>

type Stored = &'tcx Body<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx Body<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for orphan_check_impl<'tcx>

type Key = LocalDefId

type Value = Result<(), ErrorGuaranteed>

type Stored = Result<(), ErrorGuaranteed>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for output_filenames<'tcx>

type Key = ()

type Value = &'tcx Arc<OutputFilenames>

type Stored = &'tcx Arc<OutputFilenames>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx Arc<OutputFilenames>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for own_existential_vtable_entries<'tcx>

type Key = DefId

type Value = &'tcx [DefId]

type Stored = &'tcx [DefId]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [DefId]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for panic_in_drop_strategy<'tcx>

type Key = CrateNum

type Value = PanicStrategy

type Stored = PanicStrategy

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for param_env<'tcx>

type Key = DefId

type Value = ParamEnv<'tcx>

type Stored = ParamEnv<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ParamEnv<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for param_env_reveal_all_normalized<'tcx>

type Key = DefId

type Value = ParamEnv<'tcx>

type Stored = ParamEnv<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ParamEnv<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for params_in_repr<'tcx>

type Key = DefId

type Value = BitSet<u32>

type Stored = &'tcx BitSet<u32>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, BitSet<u32>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for parent_module_from_def_id<'tcx>

type Key = LocalDefId

type Value = LocalDefId

type Stored = LocalDefId

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for permits_uninit_init<'tcx>

type Key = TyAndLayout<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<TyAndLayout<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for permits_zero_init<'tcx>

type Key = TyAndLayout<'tcx, Ty<'tcx>>

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<TyAndLayout<'tcx, Ty<'tcx>>, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for postorder_cnums<'tcx>

type Key = ()

type Value = &'tcx [CrateNum]

type Stored = &'tcx [CrateNum]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx [CrateNum]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for predicates_defined_on<'tcx>

type Key = DefId

type Value = GenericPredicates<'tcx>

type Stored = GenericPredicates<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for predicates_of<'tcx>

type Key = DefId

type Value = GenericPredicates<'tcx>

type Stored = GenericPredicates<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for proc_macro_decls_static<'tcx>

type Key = ()

type Value = Option<LocalDefId>

type Stored = Option<LocalDefId>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), Option<LocalDefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for promoted_mir<'tcx>

type Key = DefId

type Value = &'tcx IndexVec<Promoted, Body<'tcx>>

type Stored = &'tcx IndexVec<Promoted, Body<'tcx>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx IndexVec<Promoted, Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for promoted_mir_of_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = &'tcx IndexVec<Promoted, Body<'tcx>>

type Stored = &'tcx IndexVec<Promoted, Body<'tcx>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx IndexVec<Promoted, Body<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for reachable_non_generics<'tcx>

type Key = CrateNum

type Value = HashMap<DefId, SymbolExportInfo, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<DefId, SymbolExportInfo, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for reachable_set<'tcx>

type Key = ()

type Value = HashSet<LocalDefId, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashSet<LocalDefId, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashSet<LocalDefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for region_scope_tree<'tcx>

type Key = DefId

type Value = &'tcx ScopeTree

type Stored = &'tcx ScopeTree

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx ScopeTree>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for rendered_const<'tcx>

type Key = DefId

type Value = String

type Stored = &'tcx String

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, String>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for representability<'tcx>

type Key = LocalDefId

type Value = Representability

type Stored = Representability

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<LocalDefId, Representability>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for representability_adt_ty<'tcx>

type Key = Ty<'tcx>

type Value = Representability

type Stored = Representability

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Ty<'tcx>, Representability>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for required_panic_strategy<'tcx>

type Key = CrateNum

type Value = Option<PanicStrategy>

type Stored = Option<PanicStrategy>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for resolutions<'tcx>

type Key = ()

type Value = &'tcx ResolverGlobalCtxt

type Stored = &'tcx ResolverGlobalCtxt

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx ResolverGlobalCtxt>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for resolve_instance<'tcx>

type Key = ParamEnvAnd<'tcx, (DefId, &'tcx List<GenericArg<'tcx>>)>

type Value = Result<Option<Instance<'tcx>>, ErrorGuaranteed>

type Stored = Result<Option<Instance<'tcx>>, ErrorGuaranteed>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, (DefId, &'tcx List<GenericArg<'tcx>>)>, Result<Option<Instance<'tcx>>, ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for resolve_instance_of_const_arg<'tcx>

type Key = ParamEnvAnd<'tcx, (LocalDefId, DefId, &'tcx List<GenericArg<'tcx>>)>

type Value = Result<Option<Instance<'tcx>>, ErrorGuaranteed>

type Stored = Result<Option<Instance<'tcx>>, ErrorGuaranteed>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, (LocalDefId, DefId, &'tcx List<GenericArg<'tcx>>)>, Result<Option<Instance<'tcx>>, ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for resolve_lifetimes<'tcx>

type Key = OwnerId

type Value = ResolveLifetimes

type Stored = &'tcx ResolveLifetimes

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'tcx, OwnerId, 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> QueryConfig<QueryCtxt<'tcx>> for resolver_for_lowering<'tcx>

type Key = ()

type Value = &'tcx Steal<ResolverAstLowering>

type Stored = &'tcx Steal<ResolverAstLowering>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), &'tcx Steal<ResolverAstLowering>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for reveal_opaque_types_in_bounds<'tcx>

type Key = &'tcx List<Predicate<'tcx>>

type Value = &'tcx List<Predicate<'tcx>>

type Stored = &'tcx List<Predicate<'tcx>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<&'tcx List<Predicate<'tcx>>, &'tcx List<Predicate<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for shallow_lint_levels_on<'tcx>

type Key = OwnerId

type Value = ShallowLintLevelMap

type Stored = &'tcx ShallowLintLevelMap

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'tcx, OwnerId, ShallowLintLevelMap>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for should_inherit_track_caller<'tcx>

type Key = DefId

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for source_span<'tcx>

type Key = LocalDefId

type Value = Span

type Stored = Span

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for specialization_graph_of<'tcx>

type Key = DefId

type Value = Graph

type Stored = &'tcx Graph

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, Graph>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for specializes<'tcx>

type Key = (DefId, DefId)

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, DefId), bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for stability_implications<'tcx>

type Key = CrateNum

type Value = HashMap<Symbol, Symbol, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<Symbol, Symbol, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for stability_index<'tcx>

type Key = ()

type Value = Index

type Stored = &'tcx Index

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), Index>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for subst_and_check_impossible_predicates<'tcx>

type Key = (DefId, &'tcx List<GenericArg<'tcx>>)

type Value = bool

type Stored = bool

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, &'tcx List<GenericArg<'tcx>>), bool>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for super_predicates_of<'tcx>

type Key = DefId

type Value = GenericPredicates<'tcx>

type Stored = GenericPredicates<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for super_predicates_that_define_assoc_type<'tcx>

type Key = (DefId, Option<Ident>)

type Value = GenericPredicates<'tcx>

type Stored = GenericPredicates<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, Option<Ident>), GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for supported_target_features<'tcx>

type Key = CrateNum

type Value = HashMap<String, Option<Symbol>, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<String, Option<Symbol>, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for symbol_mangling_version<'tcx>

type Key = CrateNum

type Value = SymbolManglingVersion

type Stored = SymbolManglingVersion

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for symbol_name<'tcx>

type Key = Instance<'tcx>

type Value = SymbolName<'tcx>

type Stored = SymbolName<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Instance<'tcx>, SymbolName<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for symbols_for_closure_captures<'tcx>

type Key = (LocalDefId, LocalDefId)

type Value = Vec<Symbol, Global>

type Stored = &'tcx Vec<Symbol, Global>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (LocalDefId, LocalDefId), Vec<Symbol, Global>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for thir_abstract_const<'tcx>

type Key = DefId

type Value = Result<Option<Const<'tcx>>, ErrorGuaranteed>

type Stored = Result<Option<Const<'tcx>>, ErrorGuaranteed>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Result<Option<Const<'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> QueryConfig<QueryCtxt<'tcx>> for thir_abstract_const_of_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = Result<Option<Const<'tcx>>, ErrorGuaranteed>

type Stored = Result<Option<Const<'tcx>>, ErrorGuaranteed>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), Result<Option<Const<'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> QueryConfig<QueryCtxt<'tcx>> for thir_body<'tcx>

type Key = WithOptConstParam<LocalDefId>

type Value = Result<(&'tcx Steal<Thir<'tcx>>, ExprId), ErrorGuaranteed>

type Stored = Result<(&'tcx Steal<Thir<'tcx>>, ExprId), ErrorGuaranteed>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<WithOptConstParam<LocalDefId>, Result<(&'tcx Steal<Thir<'tcx>>, ExprId), ErrorGuaranteed>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for thir_check_unsafety<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for thir_check_unsafety_for_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = ()

type Stored = ()

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for thir_tree<'tcx>

type Key = WithOptConstParam<LocalDefId>

type Value = String

type Stored = &'tcx String

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, WithOptConstParam<LocalDefId>, String>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for trait_def<'tcx>

type Key = DefId

type Value = TraitDef

type Stored = &'tcx TraitDef

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, TraitDef>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for trait_explicit_predicates_and_bounds<'tcx>

type Key = LocalDefId

type Value = GenericPredicates<'tcx>

type Stored = GenericPredicates<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for trait_impls_of<'tcx>

type Key = DefId

type Value = TraitImpls

type Stored = &'tcx TraitImpls

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, TraitImpls>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for traits_in_crate<'tcx>

type Key = CrateNum

type Value = &'tcx [DefId]

type Stored = &'tcx [DefId]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for trigger_delay_span_bug<'tcx>

type Key = DefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for trimmed_def_paths<'tcx>

type Key = ()

type Value = HashMap<DefId, Symbol, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<DefId, Symbol, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashMap<DefId, Symbol, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for try_destructure_mir_constant<'tcx>

type Key = ParamEnvAnd<'tcx, ConstantKind<'tcx>>

type Value = Option<DestructuredConstant<'tcx>>

type Stored = Option<DestructuredConstant<'tcx>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, ConstantKind<'tcx>>, Option<DestructuredConstant<'tcx>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for try_normalize_generic_arg_after_erasing_regions<'tcx>

type Key = ParamEnvAnd<'tcx, GenericArg<'tcx>>

type Value = Result<GenericArg<'tcx>, NoSolution>

type Stored = Result<GenericArg<'tcx>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<ParamEnvAnd<'tcx, GenericArg<'tcx>>, Result<GenericArg<'tcx>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_of<'tcx>

type Key = DefId

type Value = Ty<'tcx>

type Stored = Ty<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Ty<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_ascribe_user_type<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, AscribeUserType<'tcx>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, AscribeUserType<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_eq<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Eq<'tcx>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Eq<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_normalize_fn_sig<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<FnSig<'tcx>>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, FnSig<'tcx>>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, FnSig<'tcx>>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<FnSig<'tcx>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, FnSig<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_normalize_poly_fn_sig<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Binder<'tcx, FnSig<'tcx>>>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Binder<'tcx, FnSig<'tcx>>>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Binder<'tcx, FnSig<'tcx>>>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Binder<'tcx, FnSig<'tcx>>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Binder<'tcx, FnSig<'tcx>>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_normalize_predicate<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Predicate<'tcx>>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Predicate<'tcx>>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Predicate<'tcx>>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Predicate<'tcx>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Predicate<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_normalize_ty<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Ty<'tcx>>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Ty<'tcx>>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_prove_predicate<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, ProvePredicate<'tcx>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, ProvePredicate<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_op_subtype<'tcx>

type Key = Canonical<'tcx, ParamEnvAnd<'tcx, Subtype<'tcx>>>

type Value = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

type Stored = Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Canonical<'tcx, ParamEnvAnd<'tcx, Subtype<'tcx>>>, Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for type_param_predicates<'tcx>

type Key = (DefId, LocalDefId, Ident)

type Value = GenericPredicates<'tcx>

type Stored = GenericPredicates<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(DefId, LocalDefId, Ident), GenericPredicates<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for typeck<'tcx>

type Key = LocalDefId

type Value = &'tcx TypeckResults<'tcx>

type Stored = &'tcx TypeckResults<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for typeck_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = &'tcx TypeckResults<'tcx>

type Stored = &'tcx TypeckResults<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx TypeckResults<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for typeck_item_bodies<'tcx>

type Key = ()

type Value = ()

type Stored = ()

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(), ()>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for unsafe_derive_on_repr_packed<'tcx>

type Key = LocalDefId

type Value = ()

type Stored = ()

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for unsafety_check_result<'tcx>

type Key = LocalDefId

type Value = &'tcx UnsafetyCheckResult

type Stored = &'tcx UnsafetyCheckResult

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<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> QueryConfig<QueryCtxt<'tcx>> for unsafety_check_result_for_const_arg<'tcx>

type Key = (LocalDefId, DefId)

type Value = &'tcx UnsafetyCheckResult

type Stored = &'tcx UnsafetyCheckResult

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(LocalDefId, DefId), &'tcx UnsafetyCheckResult>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for unused_generic_params<'tcx>

type Key = InstanceDef<'tcx>

type Value = FiniteBitSet<u32>

type Stored = FiniteBitSet<u32>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<InstanceDef<'tcx>, FiniteBitSet<u32>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for upstream_drop_glue_for<'tcx>

type Key = &'tcx List<GenericArg<'tcx>>

type Value = Option<CrateNum>

type Stored = Option<CrateNum>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<&'tcx List<GenericArg<'tcx>>, Option<CrateNum>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for upstream_monomorphizations<'tcx>

type Key = ()

type Value = HashMap<DefId, HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<DefId, HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashMap<DefId, HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for upstream_monomorphizations_for<'tcx>

type Key = DefId

type Value = Option<&'tcx HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>>

type Stored = &'tcx Option<&'tcx HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, DefId, Option<&'tcx HashMap<&'tcx List<GenericArg<'tcx>>, CrateNum, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for upvars_mentioned<'tcx>

type Key = DefId

type Value = Option<&'tcx IndexMap<HirId, Upvar, BuildHasherDefault<FxHasher>>>

type Stored = Option<&'tcx IndexMap<HirId, Upvar, BuildHasherDefault<FxHasher>>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Option<&'tcx IndexMap<HirId, Upvar, BuildHasherDefault<FxHasher>>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for used_crate_source<'tcx>

type Key = CrateNum

type Value = Rc<CrateSource>

type Stored = &'tcx Rc<CrateSource>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'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> QueryConfig<QueryCtxt<'tcx>> for used_trait_imports<'tcx>

type Key = LocalDefId

type Value = &'tcx UnordSet<LocalDefId>

type Stored = &'tcx UnordSet<LocalDefId>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecCache<LocalDefId, &'tcx UnordSet<LocalDefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for valtree_to_const_val<'tcx>

type Key = (Ty<'tcx>, ValTree<'tcx>)

type Value = ConstValue<'tcx>

type Stored = ConstValue<'tcx>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Ty<'tcx>, ValTree<'tcx>), ConstValue<'tcx>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for variances_of<'tcx>

type Key = DefId

type Value = &'tcx [Variance]

type Stored = &'tcx [Variance]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, &'tcx [Variance]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for visibility<'tcx>

type Key = DefId

type Value = Visibility<DefId>

type Stored = Visibility<DefId>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<DefId, Visibility<DefId>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for visible_parent_map<'tcx>

type Key = ()

type Value = HashMap<DefId, DefId, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<DefId, DefId, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = ArenaCache<'tcx, (), HashMap<DefId, DefId, BuildHasherDefault<FxHasher>>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for vtable_allocation<'tcx>

type Key = (Ty<'tcx>, Option<Binder<'tcx, ExistentialTraitRef<'tcx>>>)

type Value = AllocId

type Stored = AllocId

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Ty<'tcx>, Option<Binder<'tcx, ExistentialTraitRef<'tcx>>>), AllocId>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for vtable_entries<'tcx>

type Key = Binder<'tcx, TraitRef<'tcx>>

type Value = &'tcx [VtblEntry<'tcx>]

type Stored = &'tcx [VtblEntry<'tcx>]

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<Binder<'tcx, TraitRef<'tcx>>, &'tcx [VtblEntry<'tcx>]>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for vtable_trait_upcasting_coercion_new_vptr_slot<'tcx>

type Key = (Ty<'tcx>, Ty<'tcx>)

type Value = Option<usize>

type Stored = Option<usize>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = DefaultCache<(Ty<'tcx>, Ty<'tcx>), Option<usize>>

fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>where
    QueryCtxt<'tcx>: 'a,

fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cachewhere
    'tcx: 'a,

fn make_vtable(
    tcx: QueryCtxt<'tcx>,
    key: &Self::Key
) -> QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>

fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored

impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for wasm_import_module_map<'tcx>

type Key = CrateNum

type Value = HashMap<DefId, String, BuildHasherDefault<FxHasher>>

type Stored = &'tcx HashMap<DefId, String, BuildHasherDefault<FxHasher>>

const NAME: &'static str = _

fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool

type Cache = VecArenaCache<'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 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> 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