[rustc.git] / compiler / rustc_middle / src / query / keys.rs

//! Defines the set of legal keys that can be used in queries.

use crate::infer::canonical::Canonical;
use crate::mir;
use crate::traits;
use crate::ty::fast_reject::SimplifiedType;
use crate::ty::layout::{TyAndLayout, ValidityRequirement};
use crate::ty::subst::{GenericArg, SubstsRef};
use crate::ty::{self, Ty, TyCtxt};
use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
use rustc_hir::hir_id::{HirId, OwnerId};
use rustc_query_system::query::{DefaultCacheSelector, SingleCacheSelector, VecCacheSelector};
use rustc_span::symbol::{Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};

/// The `Key` trait controls what types can legally be used as the key
/// for a query.
pub trait Key: Sized {
    // N.B. Most of the keys down below have `type CacheSelector = DefaultCacheSelector<Self>;`,
    //      it would be reasonable to use associated type defaults, to remove the duplication...
    //
    //      ...But r-a doesn't support them yet and using a default here causes r-a to not infer
    //      return types of queries which is very annoying. Thus, until r-a support associated
    //      type defaults, plese restrain from using them here <3
    //
    //      r-a issue: <https://github.com/rust-lang/rust-analyzer/issues/13693>
    type CacheSelector;

    /// Given an instance of this key, what crate is it referring to?
    /// This is used to find the provider.
    fn query_crate_is_local(&self) -> bool;

    /// 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?
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span;

    /// If the key is a [`DefId`] or `DefId`--equivalent, return that `DefId`.
    /// Otherwise, return `None`.
    fn key_as_def_id(&self) -> Option<DefId> {
        None
    }

    fn ty_adt_id(&self) -> Option<DefId> {
        None
    }
}

impl Key for () {
    type CacheSelector = SingleCacheSelector;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for ty::InstanceDef<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(self.def_id())
    }
}

impl<'tcx> Key for ty::Instance<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(self.def_id())
    }
}

impl<'tcx> Key for mir::interpret::GlobalId<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for mir::interpret::LitToConstInput<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl Key for CrateNum {
    type CacheSelector = VecCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        *self == LOCAL_CRATE
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl Key for OwnerId {
    type CacheSelector = VecCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.to_def_id().default_span(tcx)
    }
    fn key_as_def_id(&self) -> Option<DefId> {
        Some(self.to_def_id())
    }
}

impl Key for LocalDefId {
    type CacheSelector = VecCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.to_def_id().default_span(tcx)
    }
    fn key_as_def_id(&self) -> Option<DefId> {
        Some(self.to_def_id())
    }
}

impl Key for DefId {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(*self)
    }
    #[inline(always)]
    fn key_as_def_id(&self) -> Option<DefId> {
        Some(*self)
    }
}

impl Key for ty::WithOptConstParam<LocalDefId> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.did.default_span(tcx)
    }
}

impl Key for SimplifiedType {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl Key for (DefId, DefId) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.1.default_span(tcx)
    }
}

impl<'tcx> Key for (ty::Instance<'tcx>, LocalDefId) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.0.default_span(tcx)
    }
}

impl Key for (DefId, LocalDefId) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.1.default_span(tcx)
    }
}

impl Key for (LocalDefId, DefId) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.0.default_span(tcx)
    }
}

impl Key for (LocalDefId, LocalDefId) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.0.default_span(tcx)
    }
}

impl Key for (DefId, Option<Ident>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(self.0)
    }
    #[inline(always)]
    fn key_as_def_id(&self) -> Option<DefId> {
        Some(self.0)
    }
}

impl Key for (DefId, LocalDefId, Ident) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.1.default_span(tcx)
    }
}

impl Key for (CrateNum, DefId) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0 == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.1.default_span(tcx)
    }
}

impl Key for (CrateNum, SimplifiedType) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0 == LOCAL_CRATE
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl Key for (DefId, SimplifiedType) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.0.default_span(tcx)
    }
}

impl<'tcx> Key for SubstsRef<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for (DefId, SubstsRef<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.0.default_span(tcx)
    }
}

impl<'tcx> Key for (ty::UnevaluatedConst<'tcx>, ty::UnevaluatedConst<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        (self.0).def.did.krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        (self.0).def.did.default_span(tcx)
    }
}

impl<'tcx> Key for (LocalDefId, DefId, SubstsRef<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.0.default_span(tcx)
    }
}

impl<'tcx> Key for (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.1.def_id().krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(self.1.def_id())
    }
}

impl<'tcx> Key for (ty::Const<'tcx>, mir::Field) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for mir::interpret::ConstAlloc<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for ty::PolyTraitRef<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.def_id().krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(self.def_id())
    }
}

impl<'tcx> Key for ty::PolyExistentialTraitRef<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.def_id().krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(self.def_id())
    }
}

impl<'tcx> Key for (ty::PolyTraitRef<'tcx>, ty::PolyTraitRef<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.0.def_id().krate == LOCAL_CRATE
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.def_span(self.0.def_id())
    }
}

impl<'tcx> Key for GenericArg<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for mir::ConstantKind<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for ty::Const<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for Ty<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
    fn ty_adt_id(&self) -> Option<DefId> {
        match self.kind() {
            ty::Adt(adt, _) => Some(adt.did()),
            _ => None,
        }
    }
}

impl<'tcx> Key for TyAndLayout<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for (Ty<'tcx>, Ty<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for &'tcx ty::List<ty::Predicate<'tcx>> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx> Key for ty::ParamEnv<'tcx> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl<'tcx, T: Key> Key for ty::ParamEnvAnd<'tcx, T> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        self.value.query_crate_is_local()
    }
    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        self.value.default_span(tcx)
    }
}

impl Key for Symbol {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

impl Key for Option<Symbol> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }
    fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
        DUMMY_SP
    }
}

/// Canonical query goals correspond to abstract trait operations that
/// are not tied to any crate in particular.
impl<'tcx, T> Key for Canonical<'tcx, T> {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl Key for (Symbol, u32, u32) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for (DefId, Ty<'tcx>, SubstsRef<'tcx>, ty::ParamEnv<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for (ty::Predicate<'tcx>, traits::WellFormedLoc) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for (ty::PolyFnSig<'tcx>, &'tcx ty::List<Ty<'tcx>>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl<'tcx> Key for (Ty<'tcx>, ty::ValTree<'tcx>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

impl Key for HirId {
    type CacheSelector = DefaultCacheSelector<Self>;

    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
        tcx.hir().span(*self)
    }

    #[inline(always)]
    fn key_as_def_id(&self) -> Option<DefId> {
        None
    }
}

impl<'tcx> Key for (ValidityRequirement, ty::ParamEnvAnd<'tcx, Ty<'tcx>>) {
    type CacheSelector = DefaultCacheSelector<Self>;

    // Just forward to `Ty<'tcx>`
    #[inline(always)]
    fn query_crate_is_local(&self) -> bool {
        true
    }

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

    fn ty_adt_id(&self) -> Option<DefId> {
        match self.1.value.kind() {
            ty::Adt(adt, _) => Some(adt.did()),
            _ => None,
        }
    }
}
Commit	Line	Data
ea8adc8c XL	1	//! Defines the set of legal keys that can be used in queries.
ea8adc8c XL	2
487cf647 FG	3	use crate::infer::canonical::Canonical;
	4	use crate::mir;
	5	use crate::traits;
	6	use crate::ty::fast_reject::SimplifiedType;
9ffffee4	7	use crate::ty::layout::{TyAndLayout, ValidityRequirement};
487cf647	8	use crate::ty::subst::{GenericArg, SubstsRef};
9ffffee4	9	use crate::ty::{self, Ty, TyCtxt};
ba9703b0	10	use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
2b03887a	11	use rustc_hir::hir_id::{HirId, OwnerId};
9ffffee4	12	use rustc_query_system::query::{DefaultCacheSelector, SingleCacheSelector, VecCacheSelector};
6a06907d	13	use rustc_span::symbol::{Ident, Symbol};
dfeec247	14	use rustc_span::{Span, DUMMY_SP};
ea8adc8c XL	15
	16	/// The `Key` trait controls what types can legally be used as the key
	17	/// for a query.
487cf647	18	pub trait Key: Sized {
9c376795 FG	19	// N.B. Most of the keys down below have `type CacheSelector = DefaultCacheSelector<Self>;`,
	20	// it would be reasonable to use associated type defaults, to remove the duplication...
	21	//
	22	// ...But r-a doesn't support them yet and using a default here causes r-a to not infer
	23	// return types of queries which is very annoying. Thus, until r-a support associated
	24	// type defaults, plese restrain from using them here <3
	25	//
	26	// r-a issue: <https://github.com/rust-lang/rust-analyzer/issues/13693>
	27	type CacheSelector;
487cf647	28
ea8adc8c XL	29	/// Given an instance of this key, what crate is it referring to?
ea8adc8c XL	30	/// This is used to find the provider.
136023e0	31	fn query_crate_is_local(&self) -> bool;
ea8adc8c XL	32
	33	/// In the event that a cycle occurs, if no explicit span has been
	34	/// given for a query with key `self`, what span should we use?
dc9dc135	35	fn default_span(&self, tcx: TyCtxt<'_>) -> Span;
94222f64 XL	36
	37	/// If the key is a [`DefId`] or `DefId`--equivalent, return that `DefId`.
	38	/// Otherwise, return `None`.
	39	fn key_as_def_id(&self) -> Option<DefId> {
	40	None
	41	}
2b03887a FG	42
	43	fn ty_adt_id(&self) -> Option<DefId> {
	44	None
	45	}
ea8adc8c XL	46	}
ea8adc8c XL	47
17df50a5	48	impl Key for () {
9ffffee4	49	type CacheSelector = SingleCacheSelector;
9c376795	50
136023e0 XL	51	#[inline(always)]
	52	fn query_crate_is_local(&self) -> bool {
	53	true
17df50a5 XL	54	}
	55
	56	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	57	DUMMY_SP
	58	}
	59	}
	60
ea8adc8c	61	impl<'tcx> Key for ty::InstanceDef<'tcx> {
9c376795 FG	62	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	63
136023e0 XL	64	#[inline(always)]
	65	fn query_crate_is_local(&self) -> bool {
	66	true
ea8adc8c XL	67	}
ea8adc8c XL	68
dc9dc135	69	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	70	tcx.def_span(self.def_id())
	71	}
	72	}
	73
	74	impl<'tcx> Key for ty::Instance<'tcx> {
9c376795 FG	75	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	76
136023e0 XL	77	#[inline(always)]
	78	fn query_crate_is_local(&self) -> bool {
	79	true
ea8adc8c XL	80	}
ea8adc8c XL	81
dc9dc135	82	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	83	tcx.def_span(self.def_id())
	84	}
	85	}
	86
0531ce1d	87	impl<'tcx> Key for mir::interpret::GlobalId<'tcx> {
9c376795 FG	88	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	89
136023e0 XL	90	#[inline(always)]
	91	fn query_crate_is_local(&self) -> bool {
	92	true
0531ce1d XL	93	}
0531ce1d XL	94
dc9dc135	95	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
0531ce1d XL	96	self.instance.default_span(tcx)
	97	}
	98	}
	99
dc3f5686	100	impl<'tcx> Key for (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>) {
9c376795 FG	101	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	102
dc3f5686 XL	103	#[inline(always)]
	104	fn query_crate_is_local(&self) -> bool {
	105	true
	106	}
	107
	108	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	109	DUMMY_SP
	110	}
	111	}
	112
dfeec247	113	impl<'tcx> Key for mir::interpret::LitToConstInput<'tcx> {
9c376795 FG	114	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	115
136023e0 XL	116	#[inline(always)]
	117	fn query_crate_is_local(&self) -> bool {
	118	true
dfeec247 XL	119	}
	120
	121	fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
	122	DUMMY_SP
	123	}
	124	}
	125
ea8adc8c	126	impl Key for CrateNum {
487cf647 FG	127	type CacheSelector = VecCacheSelector<Self>;
487cf647 FG	128
136023e0 XL	129	#[inline(always)]
	130	fn query_crate_is_local(&self) -> bool {
	131	*self == LOCAL_CRATE
ea8adc8c	132	}
dc9dc135	133	fn default_span(&self, _: TyCtxt<'_>) -> Span {
ea8adc8c XL	134	DUMMY_SP
	135	}
	136	}
	137
2b03887a	138	impl Key for OwnerId {
487cf647 FG	139	type CacheSelector = VecCacheSelector<Self>;
487cf647 FG	140
2b03887a FG	141	#[inline(always)]
	142	fn query_crate_is_local(&self) -> bool {
	143	true
	144	}
	145	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	146	self.to_def_id().default_span(tcx)
	147	}
	148	fn key_as_def_id(&self) -> Option<DefId> {
	149	Some(self.to_def_id())
	150	}
	151	}
	152
ba9703b0	153	impl Key for LocalDefId {
487cf647 FG	154	type CacheSelector = VecCacheSelector<Self>;
487cf647 FG	155
136023e0 XL	156	#[inline(always)]
	157	fn query_crate_is_local(&self) -> bool {
	158	true
ea8adc8c	159	}
ba9703b0 XL	160	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ba9703b0 XL	161	self.to_def_id().default_span(tcx)
ea8adc8c	162	}
94222f64 XL	163	fn key_as_def_id(&self) -> Option<DefId> {
	164	Some(self.to_def_id())
	165	}
ea8adc8c XL	166	}
	167
	168	impl Key for DefId {
9c376795 FG	169	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	170
136023e0 XL	171	#[inline(always)]
	172	fn query_crate_is_local(&self) -> bool {
	173	self.krate == LOCAL_CRATE
ea8adc8c	174	}
dc9dc135	175	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	176	tcx.def_span(*self)
ea8adc8c XL	177	}
94222f64 XL	178	#[inline(always)]
	179	fn key_as_def_id(&self) -> Option<DefId> {
	180	Some(*self)
	181	}
ea8adc8c XL	182	}
ea8adc8c XL	183
3dfed10e	184	impl Key for ty::WithOptConstParam<LocalDefId> {
9c376795 FG	185	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	186
136023e0 XL	187	#[inline(always)]
	188	fn query_crate_is_local(&self) -> bool {
	189	true
3dfed10e XL	190	}
	191	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	192	self.did.default_span(tcx)
	193	}
	194	}
	195
5e7ed085	196	impl Key for SimplifiedType {
9c376795 FG	197	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	198
5e7ed085 FG	199	#[inline(always)]
	200	fn query_crate_is_local(&self) -> bool {
	201	true
	202	}
	203	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	204	DUMMY_SP
	205	}
	206	}
	207
ea8adc8c	208	impl Key for (DefId, DefId) {
9c376795 FG	209	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	210
136023e0 XL	211	#[inline(always)]
	212	fn query_crate_is_local(&self) -> bool {
	213	self.0.krate == LOCAL_CRATE
ea8adc8c	214	}
dc9dc135	215	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	216	self.1.default_span(tcx)
	217	}
	218	}
	219
a2a8927a	220	impl<'tcx> Key for (ty::Instance<'tcx>, LocalDefId) {
9c376795 FG	221	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	222
136023e0 XL	223	#[inline(always)]
	224	fn query_crate_is_local(&self) -> bool {
	225	true
5869c6ff XL	226	}
	227	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	228	self.0.default_span(tcx)
	229	}
	230	}
	231
f9f354fc	232	impl Key for (DefId, LocalDefId) {
9c376795 FG	233	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	234
136023e0 XL	235	#[inline(always)]
	236	fn query_crate_is_local(&self) -> bool {
	237	self.0.krate == LOCAL_CRATE
f9f354fc XL	238	}
	239	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	240	self.1.default_span(tcx)
	241	}
	242	}
	243
3dfed10e	244	impl Key for (LocalDefId, DefId) {
9c376795 FG	245	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	246
136023e0 XL	247	#[inline(always)]
	248	fn query_crate_is_local(&self) -> bool {
	249	true
3dfed10e XL	250	}
	251	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	252	self.0.default_span(tcx)
	253	}
	254	}
	255
064997fb	256	impl Key for (LocalDefId, LocalDefId) {
9c376795 FG	257	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	258
064997fb FG	259	#[inline(always)]
	260	fn query_crate_is_local(&self) -> bool {
	261	true
	262	}
	263	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	264	self.0.default_span(tcx)
	265	}
	266	}
	267
6a06907d	268	impl Key for (DefId, Option<Ident>) {
9c376795 FG	269	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	270
136023e0 XL	271	#[inline(always)]
	272	fn query_crate_is_local(&self) -> bool {
	273	self.0.krate == LOCAL_CRATE
6a06907d XL	274	}
	275	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	276	tcx.def_span(self.0)
	277	}
94222f64 XL	278	#[inline(always)]
	279	fn key_as_def_id(&self) -> Option<DefId> {
	280	Some(self.0)
	281	}
6a06907d	282	}
74b04a01	283
6a06907d	284	impl Key for (DefId, LocalDefId, Ident) {
9c376795 FG	285	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	286
136023e0 XL	287	#[inline(always)]
	288	fn query_crate_is_local(&self) -> bool {
	289	self.0.krate == LOCAL_CRATE
6a06907d XL	290	}
	291	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	292	self.1.default_span(tcx)
	293	}
	294	}
	295
	296	impl Key for (CrateNum, DefId) {
9c376795 FG	297	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	298
136023e0 XL	299	#[inline(always)]
	300	fn query_crate_is_local(&self) -> bool {
	301	self.0 == LOCAL_CRATE
ea8adc8c	302	}
dc9dc135	303	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	304	self.1.default_span(tcx)
	305	}
	306	}
	307
5e7ed085	308	impl Key for (CrateNum, SimplifiedType) {
9c376795 FG	309	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	310
5e7ed085 FG	311	#[inline(always)]
	312	fn query_crate_is_local(&self) -> bool {
	313	self.0 == LOCAL_CRATE
	314	}
	315	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	316	DUMMY_SP
	317	}
	318	}
	319
ea8adc8c	320	impl Key for (DefId, SimplifiedType) {
9c376795 FG	321	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	322
136023e0 XL	323	#[inline(always)]
	324	fn query_crate_is_local(&self) -> bool {
	325	self.0.krate == LOCAL_CRATE
ea8adc8c	326	}
dc9dc135	327	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	328	self.0.default_span(tcx)
	329	}
	330	}
	331
dfeec247	332	impl<'tcx> Key for SubstsRef<'tcx> {
9c376795 FG	333	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	334
136023e0 XL	335	#[inline(always)]
	336	fn query_crate_is_local(&self) -> bool {
	337	true
dfeec247 XL	338	}
	339	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	340	DUMMY_SP
	341	}
	342	}
	343
532ac7d7	344	impl<'tcx> Key for (DefId, SubstsRef<'tcx>) {
9c376795 FG	345	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	346
136023e0 XL	347	#[inline(always)]
	348	fn query_crate_is_local(&self) -> bool {
	349	self.0.krate == LOCAL_CRATE
ea8adc8c	350	}
dc9dc135	351	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	352	self.0.default_span(tcx)
	353	}
	354	}
	355
2b03887a	356	impl<'tcx> Key for (ty::UnevaluatedConst<'tcx>, ty::UnevaluatedConst<'tcx>) {
9c376795 FG	357	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	358
136023e0 XL	359	#[inline(always)]
136023e0 XL	360	fn query_crate_is_local(&self) -> bool {
94222f64	361	(self.0).def.did.krate == LOCAL_CRATE
1b1a35ee XL	362	}
1b1a35ee XL	363	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
94222f64	364	(self.0).def.did.default_span(tcx)
1b1a35ee XL	365	}
	366	}
	367
3dfed10e	368	impl<'tcx> Key for (LocalDefId, DefId, SubstsRef<'tcx>) {
9c376795 FG	369	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	370
136023e0 XL	371	#[inline(always)]
	372	fn query_crate_is_local(&self) -> bool {
	373	true
3dfed10e XL	374	}
	375	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	376	self.0.default_span(tcx)
	377	}
	378	}
	379
abe05a73	380	impl<'tcx> Key for (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>) {
9c376795 FG	381	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	382
136023e0 XL	383	#[inline(always)]
	384	fn query_crate_is_local(&self) -> bool {
	385	self.1.def_id().krate == LOCAL_CRATE
ea8adc8c	386	}
dc9dc135	387	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
abe05a73	388	tcx.def_span(self.1.def_id())
ea8adc8c XL	389	}
	390	}
	391
5099ac24	392	impl<'tcx> Key for (ty::Const<'tcx>, mir::Field) {
9c376795 FG	393	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	394
136023e0 XL	395	#[inline(always)]
	396	fn query_crate_is_local(&self) -> bool {
	397	true
6a06907d XL	398	}
	399	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	400	DUMMY_SP
	401	}
	402	}
74b04a01	403
6a06907d	404	impl<'tcx> Key for mir::interpret::ConstAlloc<'tcx> {
9c376795 FG	405	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	406
136023e0 XL	407	#[inline(always)]
	408	fn query_crate_is_local(&self) -> bool {
	409	true
dc9dc135 XL	410	}
	411	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	412	DUMMY_SP
	413	}
	414	}
	415
	416	impl<'tcx> Key for ty::PolyTraitRef<'tcx> {
9c376795 FG	417	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	418
136023e0 XL	419	#[inline(always)]
	420	fn query_crate_is_local(&self) -> bool {
	421	self.def_id().krate == LOCAL_CRATE
ea8adc8c	422	}
dc9dc135	423	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
abe05a73	424	tcx.def_span(self.def_id())
ea8adc8c XL	425	}
	426	}
	427
c295e0f8	428	impl<'tcx> Key for ty::PolyExistentialTraitRef<'tcx> {
9c376795 FG	429	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	430
c295e0f8 XL	431	#[inline(always)]
	432	fn query_crate_is_local(&self) -> bool {
	433	self.def_id().krate == LOCAL_CRATE
	434	}
	435	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	436	tcx.def_span(self.def_id())
	437	}
	438	}
	439
94222f64	440	impl<'tcx> Key for (ty::PolyTraitRef<'tcx>, ty::PolyTraitRef<'tcx>) {
9c376795 FG	441	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	442
94222f64 XL	443	#[inline(always)]
	444	fn query_crate_is_local(&self) -> bool {
	445	self.0.def_id().krate == LOCAL_CRATE
	446	}
	447	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	448	tcx.def_span(self.0.def_id())
	449	}
	450	}
	451
ba9703b0	452	impl<'tcx> Key for GenericArg<'tcx> {
9c376795 FG	453	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	454
136023e0 XL	455	#[inline(always)]
	456	fn query_crate_is_local(&self) -> bool {
	457	true
ba9703b0 XL	458	}
	459	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	460	DUMMY_SP
	461	}
	462	}
	463
cdc7bbd5	464	impl<'tcx> Key for mir::ConstantKind<'tcx> {
9c376795 FG	465	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	466
136023e0 XL	467	#[inline(always)]
	468	fn query_crate_is_local(&self) -> bool {
	469	true
cdc7bbd5 XL	470	}
	471	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	472	DUMMY_SP
	473	}
	474	}
	475
5099ac24	476	impl<'tcx> Key for ty::Const<'tcx> {
9c376795 FG	477	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	478
136023e0 XL	479	#[inline(always)]
	480	fn query_crate_is_local(&self) -> bool {
	481	true
94b46f34	482	}
dc9dc135	483	fn default_span(&self, _: TyCtxt<'_>) -> Span {
94b46f34 XL	484	DUMMY_SP
	485	}
	486	}
	487
ea8adc8c	488	impl<'tcx> Key for Ty<'tcx> {
9c376795 FG	489	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	490
136023e0	491	#[inline(always)]
94222f64 XL	492	fn query_crate_is_local(&self) -> bool {
	493	true
	494	}
064997fb FG	495	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	496	DUMMY_SP
	497	}
2b03887a FG	498	fn ty_adt_id(&self) -> Option<DefId> {
	499	match self.kind() {
	500	ty::Adt(adt, _) => Some(adt.did()),
	501	_ => None,
	502	}
	503	}
064997fb FG	504	}
	505
	506	impl<'tcx> Key for TyAndLayout<'tcx> {
9c376795 FG	507	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	508
064997fb FG	509	#[inline(always)]
	510	fn query_crate_is_local(&self) -> bool {
	511	true
	512	}
94222f64 XL	513	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	514	DUMMY_SP
	515	}
	516	}
	517
	518	impl<'tcx> Key for (Ty<'tcx>, Ty<'tcx>) {
9c376795 FG	519	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	520
94222f64	521	#[inline(always)]
136023e0 XL	522	fn query_crate_is_local(&self) -> bool {
136023e0 XL	523	true
ea8adc8c	524	}
dc9dc135	525	fn default_span(&self, _: TyCtxt<'_>) -> Span {
ea8adc8c XL	526	DUMMY_SP
	527	}
	528	}
	529
3dfed10e	530	impl<'tcx> Key for &'tcx ty::List<ty::Predicate<'tcx>> {
9c376795 FG	531	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	532
136023e0 XL	533	#[inline(always)]
	534	fn query_crate_is_local(&self) -> bool {
	535	true
3dfed10e XL	536	}
	537	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	538	DUMMY_SP
	539	}
	540	}
	541
83c7162d	542	impl<'tcx> Key for ty::ParamEnv<'tcx> {
9c376795 FG	543	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	544
136023e0 XL	545	#[inline(always)]
	546	fn query_crate_is_local(&self) -> bool {
	547	true
83c7162d	548	}
dc9dc135	549	fn default_span(&self, _: TyCtxt<'_>) -> Span {
83c7162d XL	550	DUMMY_SP
	551	}
	552	}
	553
ea8adc8c	554	impl<'tcx, T: Key> Key for ty::ParamEnvAnd<'tcx, T> {
9c376795 FG	555	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	556
136023e0 XL	557	#[inline(always)]
	558	fn query_crate_is_local(&self) -> bool {
	559	self.value.query_crate_is_local()
ea8adc8c	560	}
dc9dc135	561	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	562	self.value.default_span(tcx)
	563	}
	564	}
	565
e74abb32	566	impl Key for Symbol {
9c376795 FG	567	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	568
136023e0 XL	569	#[inline(always)]
	570	fn query_crate_is_local(&self) -> bool {
	571	true
ea8adc8c	572	}
dc9dc135	573	fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
ea8adc8c XL	574	DUMMY_SP
	575	}
	576	}
0531ce1d	577
04454e1e	578	impl Key for Option<Symbol> {
9c376795 FG	579	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	580
04454e1e FG	581	#[inline(always)]
	582	fn query_crate_is_local(&self) -> bool {
	583	true
	584	}
	585	fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
	586	DUMMY_SP
	587	}
	588	}
	589
8faf50e0 XL	590	/// Canonical query goals correspond to abstract trait operations that
8faf50e0 XL	591	/// are not tied to any crate in particular.
e74abb32	592	impl<'tcx, T> Key for Canonical<'tcx, T> {
9c376795 FG	593	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	594
136023e0 XL	595	#[inline(always)]
	596	fn query_crate_is_local(&self) -> bool {
	597	true
e74abb32 XL	598	}
	599
	600	fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
	601	DUMMY_SP
	602	}
	603	}
	604
	605	impl Key for (Symbol, u32, u32) {
9c376795 FG	606	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	607
136023e0 XL	608	#[inline(always)]
	609	fn query_crate_is_local(&self) -> bool {
	610	true
83c7162d XL	611	}
83c7162d XL	612
dc9dc135	613	fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
83c7162d XL	614	DUMMY_SP
	615	}
	616	}
ba9703b0	617
f9f354fc	618	impl<'tcx> Key for (DefId, Ty<'tcx>, SubstsRef<'tcx>, ty::ParamEnv<'tcx>) {
9c376795 FG	619	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	620
136023e0 XL	621	#[inline(always)]
	622	fn query_crate_is_local(&self) -> bool {
	623	true
	624	}
	625
	626	fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
	627	DUMMY_SP
	628	}
	629	}
	630
	631	impl<'tcx> Key for (ty::Predicate<'tcx>, traits::WellFormedLoc) {
9c376795 FG	632	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	633
136023e0 XL	634	#[inline(always)]
	635	fn query_crate_is_local(&self) -> bool {
	636	true
ba9703b0	637	}
f9f354fc XL	638
	639	fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
	640	DUMMY_SP
ba9703b0 XL	641	}
ba9703b0 XL	642	}
c295e0f8 XL	643
c295e0f8 XL	644	impl<'tcx> Key for (ty::PolyFnSig<'tcx>, &'tcx ty::List<Ty<'tcx>>) {
9c376795 FG	645	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	646
c295e0f8 XL	647	#[inline(always)]
	648	fn query_crate_is_local(&self) -> bool {
	649	true
	650	}
	651
	652	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	653	DUMMY_SP
	654	}
	655	}
	656
	657	impl<'tcx> Key for (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>) {
9c376795 FG	658	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	659
c295e0f8 XL	660	#[inline(always)]
	661	fn query_crate_is_local(&self) -> bool {
	662	true
	663	}
	664
	665	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	666	self.0.default_span(tcx)
	667	}
	668	}
04454e1e FG	669
04454e1e FG	670	impl<'tcx> Key for (Ty<'tcx>, ty::ValTree<'tcx>) {
9c376795 FG	671	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	672
04454e1e FG	673	#[inline(always)]
	674	fn query_crate_is_local(&self) -> bool {
	675	true
	676	}
	677
	678	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	679	DUMMY_SP
	680	}
	681	}
2b03887a FG	682
2b03887a FG	683	impl Key for HirId {
9c376795 FG	684	type CacheSelector = DefaultCacheSelector<Self>;
9c376795 FG	685
2b03887a FG	686	#[inline(always)]
	687	fn query_crate_is_local(&self) -> bool {
	688	true
	689	}
	690
	691	fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
	692	tcx.hir().span(*self)
	693	}
	694
	695	#[inline(always)]
	696	fn key_as_def_id(&self) -> Option<DefId> {
	697	None
	698	}
	699	}
9ffffee4 FG	700
	701	impl<'tcx> Key for (ValidityRequirement, ty::ParamEnvAnd<'tcx, Ty<'tcx>>) {
	702	type CacheSelector = DefaultCacheSelector<Self>;
	703
	704	// Just forward to `Ty<'tcx>`
	705	#[inline(always)]
	706	fn query_crate_is_local(&self) -> bool {
	707	true
	708	}
	709
	710	fn default_span(&self, _: TyCtxt<'_>) -> Span {
	711	DUMMY_SP
	712	}
	713
	714	fn ty_adt_id(&self) -> Option<DefId> {
	715	match self.1.value.kind() {
	716	ty::Adt(adt, _) => Some(adt.did()),
	717	_ => None,
	718	}
	719	}
	720	}