Trait 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>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Key for (CrateNum, DefId)

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

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

impl Key for (CrateNum, SimplifiedType)

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

fn default_span(&self, _: 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 (DefId, SimplifiedType)

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

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

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 (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 (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 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 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<'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 (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<TyCtxt<'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<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>>), V>

fn default_span(&self, _: 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 (Ty<'tcx>, VariantIdx)

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

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

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<TyCtxt<'tcx>>, UnevaluatedConst<TyCtxt<'tcx>>), V>

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

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

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

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

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

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

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

Implementors

impl Key for SimplifiedType

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

impl<'tcx> Key for InstanceKind<'tcx>

type Cache<V> = DefaultCache<InstanceKind<'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<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, V>

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

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

impl<'tcx> Key for TraitRef<'tcx>

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

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

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

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

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

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

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

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