Trait rustc_middle::query::keys::Key

pub trait Key: Sized {
    type Cache<V>;

    // Required method
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span;

    // Provided methods
    fn key_as_def_id(&self) -> Option<DefId> { ... }
    fn ty_def_id(&self) -> Option<DefId> { ... }
}

The Key trait controls what types can legally be used as the key for a query.

Required Associated Types

type Cache<V>

Required Methods

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

In the event that a cycle occurs, if no explicit span has been given for a query with key self, what span should we use?

Provided Methods

fn key_as_def_id(&self) -> Option<DefId>

If the key is a DefId or DefId–equivalent, return that DefId. Otherwise, return None.

fn ty_def_id(&self) -> Option<DefId>

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Key for (CrateNum, SimplifiedType)

type Cache<V> = DefaultCache<(CrateNum, SimplifiedType), V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

impl Key for (CrateNum, DefId)

type Cache<V> = DefaultCache<(CrateNum, DefId), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl Key for (DefId, SimplifiedType)

type Cache<V> = DefaultCache<(DefId, SimplifiedType), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl Key for (DefId, DefId)

type Cache<V> = DefaultCache<(DefId, DefId), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl Key for (DefId, LocalDefId)

type Cache<V> = DefaultCache<(DefId, LocalDefId), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl Key for (DefId, Ident)

type Cache<V> = DefaultCache<(DefId, Ident), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for (LocalDefId, HirId)

type Cache<V> = DefaultCache<(LocalDefId, HirId), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for (LocalDefId, DefId)

type Cache<V> = DefaultCache<(LocalDefId, DefId), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl Key for (LocalDefId, LocalDefId)

type Cache<V> = DefaultCache<(LocalDefId, LocalDefId), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl Key for (LocalDefId, LocalDefId, Ident)

type Cache<V> = DefaultCache<(LocalDefId, LocalDefId, Ident), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl Key for (Symbol, u32, u32)

type Cache<V> = DefaultCache<(Symbol, u32, u32), V>

fn default_span(&self, _tcx: TyCtxt<'_>) -> Span

impl Key for Option<Symbol>

type Cache<V> = DefaultCache<Option<Symbol>, V>

fn default_span(&self, _tcx: TyCtxt<'_>) -> Span

impl Key for ()

type Cache<V> = SingleCache<V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

impl Key for HirId

type Cache<V> = DefaultCache<HirId, V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for OwnerId

type Cache<V> = VecCache<OwnerId, V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for CrateNum

type Cache<V> = VecCache<CrateNum, V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

impl Key for DefId

type Cache<V> = DefIdCache<V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for LocalDefId

type Cache<V> = VecCache<LocalDefId, V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for LocalModDefId

type Cache<V> = DefaultCache<LocalModDefId, V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for ModDefId

type Cache<V> = DefaultCache<ModDefId, V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

fn key_as_def_id(&self) -> Option<DefId>

impl Key for Symbol

type Cache<V> = DefaultCache<Symbol, V>

fn default_span(&self, _tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (ValidityRequirement, ParamEnvAnd<'tcx, Ty<'tcx>>)

type Cache<V> = DefaultCache<(ValidityRequirement, ParamEnvAnd<'tcx, Ty<'tcx>>), V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

fn ty_def_id(&self) -> Option<DefId>

impl<'tcx> Key for (DefId, Ty<'tcx>, GenericArgsRef<'tcx>, ParamEnv<'tcx>)

type Cache<V> = DefaultCache<(DefId, Ty<'tcx>, &'tcx RawList<(), GenericArg<'tcx>>, ParamEnv<'tcx>), V>

fn default_span(&self, _tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (DefId, GenericArgsRef<'tcx>)

type Cache<V> = DefaultCache<(DefId, &'tcx RawList<(), GenericArg<'tcx>>), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (LocalDefId, DefId, GenericArgsRef<'tcx>)

type Cache<V> = DefaultCache<(LocalDefId, DefId, &'tcx RawList<(), GenericArg<'tcx>>), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (UnevaluatedConst<'tcx>, UnevaluatedConst<'tcx>)

type Cache<V> = DefaultCache<(UnevaluatedConst<'tcx>, UnevaluatedConst<'tcx>), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (Instance<'tcx>, &'tcx List<Ty<'tcx>>)

type Cache<V> = DefaultCache<(Instance<'tcx>, &'tcx RawList<(), Ty<'tcx>>), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (Instance<'tcx>, LocalDefId)

type Cache<V> = DefaultCache<(Instance<'tcx>, LocalDefId), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (Predicate<'tcx>, WellFormedLoc)

type Cache<V> = DefaultCache<(Predicate<'tcx>, WellFormedLoc), V>

fn default_span(&self, _tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (ParamEnv<'tcx>, TraitRef<'tcx>)

type Cache<V> = DefaultCache<(ParamEnv<'tcx>, TraitRef<'tcx>), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (Ty<'tcx>, ValTree<'tcx>)

type Cache<V> = DefaultCache<(Ty<'tcx>, ValTree<'tcx>), V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

impl<'tcx> Key for (Ty<'tcx>, Option<PolyExistentialTraitRef<'tcx>>)

type Cache<V> = DefaultCache<(Ty<'tcx>, Option<Binder<'tcx, ExistentialTraitRef<'tcx>>>), V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

impl<'tcx> Key for (Ty<'tcx>, VariantIdx)

type Cache<V> = DefaultCache<(Ty<'tcx>, VariantIdx), V>

fn default_span(&self, _tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (Ty<'tcx>, Ty<'tcx>)

type Cache<V> = DefaultCache<(Ty<'tcx>, Ty<'tcx>), V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

impl<'tcx> Key for (PolyTraitRef<'tcx>, PolyTraitRef<'tcx>)

type Cache<V> = DefaultCache<(Binder<'tcx, TraitRef<'tcx>>, Binder<'tcx, TraitRef<'tcx>>), V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

impl<'tcx> Key for (PolyFnSig<'tcx>, &'tcx List<Ty<'tcx>>)

type Cache<V> = DefaultCache<(Binder<'tcx, FnSig<'tcx>>, &'tcx RawList<(), Ty<'tcx>>), V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

Implementors

impl Key for SimplifiedType

type Cache<V> = DefaultCache<SimplifiedType, V>

impl<'tcx> Key for InstanceDef<'tcx>

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

impl<'tcx> Key for GlobalId<'tcx>

type Cache<V> = DefaultCache<GlobalId<'tcx>, V>

impl<'tcx> Key for LitToConstInput<'tcx>

type Cache<V> = DefaultCache<LitToConstInput<'tcx>, V>

impl<'tcx> Key for Const<'tcx>

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

impl<'tcx> Key for GenericArg<'tcx>

type Cache<V> = DefaultCache<GenericArg<'tcx>, V>

impl<'tcx> Key for Instance<'tcx>

type Cache<V> = DefaultCache<Instance<'tcx>, V>

impl<'tcx> Key for ParamEnv<'tcx>

type Cache<V> = DefaultCache<ParamEnv<'tcx>, V>

impl<'tcx> Key for Ty<'tcx>

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

impl<'tcx> Key for GenericArgsRef<'tcx>

type Cache<V> = DefaultCache<&'tcx RawList<(), GenericArg<'tcx>>, V>

impl<'tcx> Key for TyAndLayout<'tcx>

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

impl<'tcx> Key for PolyExistentialTraitRef<'tcx>

type Cache<V> = DefaultCache<Binder<'tcx, ExistentialTraitRef<'tcx>>, V>

impl<'tcx> Key for PolyTraitRef<'tcx>

type Cache<V> = DefaultCache<Binder<'tcx, TraitRef<'tcx>>, V>

impl<'tcx> Key for Clauses<'tcx>

type Cache<V> = DefaultCache<&'tcx RawList<TypeInfo, Clause<'tcx>>, V>

impl<'tcx, T: Clone> Key for Canonical<'tcx, T>

Canonical query goals correspond to abstract trait operations that are not tied to any crate in particular.

type Cache<V> = DefaultCache<Canonical<TyCtxt<'tcx>, T>, V>

impl<'tcx, T: Key> Key for ParamEnvAnd<'tcx, T>

type Cache<V> = DefaultCache<ParamEnvAnd<'tcx, T>, V>