]>
Commit | Line | Data |
---|---|---|
ea8adc8c XL |
1 | //! Defines the set of legal keys that can be used in queries. |
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}; |
353b0b11 FG |
15 | use rustc_target::abi::FieldIdx; |
16 | ||
17 | /// Placeholder for `CrateNum`'s "local" counterpart | |
18 | #[derive(Copy, Clone, Debug)] | |
19 | pub struct LocalCrate; | |
ea8adc8c XL |
20 | |
21 | /// The `Key` trait controls what types can legally be used as the key | |
22 | /// for a query. | |
487cf647 | 23 | pub trait Key: Sized { |
9c376795 FG |
24 | // N.B. Most of the keys down below have `type CacheSelector = DefaultCacheSelector<Self>;`, |
25 | // it would be reasonable to use associated type defaults, to remove the duplication... | |
26 | // | |
27 | // ...But r-a doesn't support them yet and using a default here causes r-a to not infer | |
28 | // return types of queries which is very annoying. Thus, until r-a support associated | |
353b0b11 | 29 | // type defaults, please restrain from using them here <3 |
9c376795 FG |
30 | // |
31 | // r-a issue: <https://github.com/rust-lang/rust-analyzer/issues/13693> | |
32 | type CacheSelector; | |
487cf647 | 33 | |
ea8adc8c XL |
34 | /// In the event that a cycle occurs, if no explicit span has been |
35 | /// given for a query with key `self`, what span should we use? | |
dc9dc135 | 36 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span; |
94222f64 XL |
37 | |
38 | /// If the key is a [`DefId`] or `DefId`--equivalent, return that `DefId`. | |
39 | /// Otherwise, return `None`. | |
40 | fn key_as_def_id(&self) -> Option<DefId> { | |
41 | None | |
42 | } | |
2b03887a FG |
43 | |
44 | fn ty_adt_id(&self) -> Option<DefId> { | |
45 | None | |
46 | } | |
ea8adc8c XL |
47 | } |
48 | ||
353b0b11 FG |
49 | pub trait AsLocalKey: Key { |
50 | type LocalKey; | |
51 | ||
52 | /// Given an instance of this key, what crate is it referring to? | |
53 | /// This is used to find the provider. | |
54 | fn as_local_key(&self) -> Option<Self::LocalKey>; | |
55 | } | |
56 | ||
17df50a5 | 57 | impl Key for () { |
9ffffee4 | 58 | type CacheSelector = SingleCacheSelector; |
9c376795 | 59 | |
17df50a5 XL |
60 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
61 | DUMMY_SP | |
62 | } | |
63 | } | |
64 | ||
ea8adc8c | 65 | impl<'tcx> Key for ty::InstanceDef<'tcx> { |
9c376795 FG |
66 | type CacheSelector = DefaultCacheSelector<Self>; |
67 | ||
dc9dc135 | 68 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
69 | tcx.def_span(self.def_id()) |
70 | } | |
71 | } | |
72 | ||
353b0b11 FG |
73 | impl<'tcx> AsLocalKey for ty::InstanceDef<'tcx> { |
74 | type LocalKey = Self; | |
9c376795 | 75 | |
136023e0 | 76 | #[inline(always)] |
353b0b11 FG |
77 | fn as_local_key(&self) -> Option<Self::LocalKey> { |
78 | self.def_id().is_local().then(|| *self) | |
ea8adc8c | 79 | } |
353b0b11 FG |
80 | } |
81 | ||
82 | impl<'tcx> Key for ty::Instance<'tcx> { | |
83 | type CacheSelector = DefaultCacheSelector<Self>; | |
ea8adc8c | 84 | |
dc9dc135 | 85 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
86 | tcx.def_span(self.def_id()) |
87 | } | |
88 | } | |
89 | ||
0531ce1d | 90 | impl<'tcx> Key for mir::interpret::GlobalId<'tcx> { |
9c376795 FG |
91 | type CacheSelector = DefaultCacheSelector<Self>; |
92 | ||
dc9dc135 | 93 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
0531ce1d XL |
94 | self.instance.default_span(tcx) |
95 | } | |
96 | } | |
97 | ||
dc3f5686 | 98 | impl<'tcx> Key for (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>) { |
9c376795 FG |
99 | type CacheSelector = DefaultCacheSelector<Self>; |
100 | ||
dc3f5686 XL |
101 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
102 | DUMMY_SP | |
103 | } | |
104 | } | |
105 | ||
dfeec247 | 106 | impl<'tcx> Key for mir::interpret::LitToConstInput<'tcx> { |
9c376795 FG |
107 | type CacheSelector = DefaultCacheSelector<Self>; |
108 | ||
dfeec247 XL |
109 | fn default_span(&self, _tcx: TyCtxt<'_>) -> Span { |
110 | DUMMY_SP | |
111 | } | |
112 | } | |
113 | ||
ea8adc8c | 114 | impl Key for CrateNum { |
487cf647 FG |
115 | type CacheSelector = VecCacheSelector<Self>; |
116 | ||
dc9dc135 | 117 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
118 | DUMMY_SP |
119 | } | |
120 | } | |
121 | ||
353b0b11 FG |
122 | impl AsLocalKey for CrateNum { |
123 | type LocalKey = LocalCrate; | |
487cf647 | 124 | |
2b03887a | 125 | #[inline(always)] |
353b0b11 FG |
126 | fn as_local_key(&self) -> Option<Self::LocalKey> { |
127 | (*self == LOCAL_CRATE).then_some(LocalCrate) | |
2b03887a | 128 | } |
353b0b11 FG |
129 | } |
130 | ||
131 | impl Key for OwnerId { | |
132 | type CacheSelector = VecCacheSelector<Self>; | |
133 | ||
2b03887a FG |
134 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
135 | self.to_def_id().default_span(tcx) | |
136 | } | |
353b0b11 | 137 | |
2b03887a FG |
138 | fn key_as_def_id(&self) -> Option<DefId> { |
139 | Some(self.to_def_id()) | |
140 | } | |
141 | } | |
142 | ||
ba9703b0 | 143 | impl Key for LocalDefId { |
487cf647 FG |
144 | type CacheSelector = VecCacheSelector<Self>; |
145 | ||
ba9703b0 XL |
146 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
147 | self.to_def_id().default_span(tcx) | |
ea8adc8c | 148 | } |
353b0b11 | 149 | |
94222f64 XL |
150 | fn key_as_def_id(&self) -> Option<DefId> { |
151 | Some(self.to_def_id()) | |
152 | } | |
ea8adc8c XL |
153 | } |
154 | ||
155 | impl Key for DefId { | |
9c376795 FG |
156 | type CacheSelector = DefaultCacheSelector<Self>; |
157 | ||
dc9dc135 | 158 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
159 | tcx.def_span(*self) |
160 | } | |
353b0b11 | 161 | |
94222f64 XL |
162 | #[inline(always)] |
163 | fn key_as_def_id(&self) -> Option<DefId> { | |
164 | Some(*self) | |
165 | } | |
ea8adc8c XL |
166 | } |
167 | ||
353b0b11 FG |
168 | impl AsLocalKey for DefId { |
169 | type LocalKey = LocalDefId; | |
9c376795 | 170 | |
136023e0 | 171 | #[inline(always)] |
353b0b11 FG |
172 | fn as_local_key(&self) -> Option<Self::LocalKey> { |
173 | self.as_local() | |
3dfed10e | 174 | } |
353b0b11 FG |
175 | } |
176 | ||
5e7ed085 | 177 | impl Key for SimplifiedType { |
9c376795 FG |
178 | type CacheSelector = DefaultCacheSelector<Self>; |
179 | ||
5e7ed085 FG |
180 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
181 | DUMMY_SP | |
182 | } | |
183 | } | |
184 | ||
ea8adc8c | 185 | impl Key for (DefId, DefId) { |
9c376795 FG |
186 | type CacheSelector = DefaultCacheSelector<Self>; |
187 | ||
dc9dc135 | 188 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
189 | self.1.default_span(tcx) |
190 | } | |
191 | } | |
192 | ||
a2a8927a | 193 | impl<'tcx> Key for (ty::Instance<'tcx>, LocalDefId) { |
9c376795 FG |
194 | type CacheSelector = DefaultCacheSelector<Self>; |
195 | ||
5869c6ff XL |
196 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
197 | self.0.default_span(tcx) | |
198 | } | |
199 | } | |
200 | ||
f9f354fc | 201 | impl Key for (DefId, LocalDefId) { |
9c376795 FG |
202 | type CacheSelector = DefaultCacheSelector<Self>; |
203 | ||
f9f354fc XL |
204 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
205 | self.1.default_span(tcx) | |
206 | } | |
207 | } | |
208 | ||
3dfed10e | 209 | impl Key for (LocalDefId, DefId) { |
9c376795 FG |
210 | type CacheSelector = DefaultCacheSelector<Self>; |
211 | ||
3dfed10e XL |
212 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
213 | self.0.default_span(tcx) | |
214 | } | |
215 | } | |
216 | ||
064997fb | 217 | impl Key for (LocalDefId, LocalDefId) { |
9c376795 FG |
218 | type CacheSelector = DefaultCacheSelector<Self>; |
219 | ||
064997fb FG |
220 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
221 | self.0.default_span(tcx) | |
222 | } | |
223 | } | |
224 | ||
353b0b11 | 225 | impl Key for (DefId, Ident) { |
9c376795 FG |
226 | type CacheSelector = DefaultCacheSelector<Self>; |
227 | ||
6a06907d XL |
228 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
229 | tcx.def_span(self.0) | |
230 | } | |
353b0b11 | 231 | |
94222f64 XL |
232 | #[inline(always)] |
233 | fn key_as_def_id(&self) -> Option<DefId> { | |
234 | Some(self.0) | |
235 | } | |
6a06907d | 236 | } |
74b04a01 | 237 | |
353b0b11 | 238 | impl Key for (LocalDefId, LocalDefId, Ident) { |
9c376795 FG |
239 | type CacheSelector = DefaultCacheSelector<Self>; |
240 | ||
6a06907d XL |
241 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
242 | self.1.default_span(tcx) | |
243 | } | |
244 | } | |
245 | ||
246 | impl Key for (CrateNum, DefId) { | |
9c376795 FG |
247 | type CacheSelector = DefaultCacheSelector<Self>; |
248 | ||
dc9dc135 | 249 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
250 | self.1.default_span(tcx) |
251 | } | |
252 | } | |
253 | ||
353b0b11 FG |
254 | impl AsLocalKey for (CrateNum, DefId) { |
255 | type LocalKey = DefId; | |
9c376795 | 256 | |
5e7ed085 | 257 | #[inline(always)] |
353b0b11 FG |
258 | fn as_local_key(&self) -> Option<Self::LocalKey> { |
259 | (self.0 == LOCAL_CRATE).then(|| self.1) | |
5e7ed085 | 260 | } |
353b0b11 FG |
261 | } |
262 | ||
263 | impl Key for (CrateNum, SimplifiedType) { | |
264 | type CacheSelector = DefaultCacheSelector<Self>; | |
265 | ||
5e7ed085 FG |
266 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
267 | DUMMY_SP | |
268 | } | |
269 | } | |
270 | ||
353b0b11 FG |
271 | impl AsLocalKey for (CrateNum, SimplifiedType) { |
272 | type LocalKey = SimplifiedType; | |
9c376795 | 273 | |
136023e0 | 274 | #[inline(always)] |
353b0b11 FG |
275 | fn as_local_key(&self) -> Option<Self::LocalKey> { |
276 | (self.0 == LOCAL_CRATE).then(|| self.1) | |
ea8adc8c | 277 | } |
353b0b11 FG |
278 | } |
279 | ||
280 | impl Key for (DefId, SimplifiedType) { | |
281 | type CacheSelector = DefaultCacheSelector<Self>; | |
282 | ||
dc9dc135 | 283 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
284 | self.0.default_span(tcx) |
285 | } | |
286 | } | |
287 | ||
dfeec247 | 288 | impl<'tcx> Key for SubstsRef<'tcx> { |
9c376795 FG |
289 | type CacheSelector = DefaultCacheSelector<Self>; |
290 | ||
dfeec247 XL |
291 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
292 | DUMMY_SP | |
293 | } | |
294 | } | |
295 | ||
532ac7d7 | 296 | impl<'tcx> Key for (DefId, SubstsRef<'tcx>) { |
9c376795 FG |
297 | type CacheSelector = DefaultCacheSelector<Self>; |
298 | ||
dc9dc135 | 299 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
300 | self.0.default_span(tcx) |
301 | } | |
302 | } | |
303 | ||
2b03887a | 304 | impl<'tcx> Key for (ty::UnevaluatedConst<'tcx>, ty::UnevaluatedConst<'tcx>) { |
9c376795 FG |
305 | type CacheSelector = DefaultCacheSelector<Self>; |
306 | ||
1b1a35ee | 307 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
49aad941 | 308 | (self.0).def.default_span(tcx) |
1b1a35ee XL |
309 | } |
310 | } | |
311 | ||
3dfed10e | 312 | impl<'tcx> Key for (LocalDefId, DefId, SubstsRef<'tcx>) { |
9c376795 FG |
313 | type CacheSelector = DefaultCacheSelector<Self>; |
314 | ||
3dfed10e XL |
315 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
316 | self.0.default_span(tcx) | |
317 | } | |
318 | } | |
319 | ||
abe05a73 | 320 | impl<'tcx> Key for (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>) { |
9c376795 FG |
321 | type CacheSelector = DefaultCacheSelector<Self>; |
322 | ||
dc9dc135 | 323 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
abe05a73 | 324 | tcx.def_span(self.1.def_id()) |
ea8adc8c XL |
325 | } |
326 | } | |
327 | ||
353b0b11 | 328 | impl<'tcx> Key for (ty::Const<'tcx>, FieldIdx) { |
9c376795 FG |
329 | type CacheSelector = DefaultCacheSelector<Self>; |
330 | ||
6a06907d XL |
331 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
332 | DUMMY_SP | |
333 | } | |
334 | } | |
74b04a01 | 335 | |
6a06907d | 336 | impl<'tcx> Key for mir::interpret::ConstAlloc<'tcx> { |
9c376795 FG |
337 | type CacheSelector = DefaultCacheSelector<Self>; |
338 | ||
dc9dc135 XL |
339 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
340 | DUMMY_SP | |
341 | } | |
342 | } | |
343 | ||
344 | impl<'tcx> Key for ty::PolyTraitRef<'tcx> { | |
9c376795 FG |
345 | type CacheSelector = DefaultCacheSelector<Self>; |
346 | ||
dc9dc135 | 347 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
abe05a73 | 348 | tcx.def_span(self.def_id()) |
ea8adc8c XL |
349 | } |
350 | } | |
351 | ||
c295e0f8 | 352 | impl<'tcx> Key for ty::PolyExistentialTraitRef<'tcx> { |
9c376795 FG |
353 | type CacheSelector = DefaultCacheSelector<Self>; |
354 | ||
c295e0f8 XL |
355 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
356 | tcx.def_span(self.def_id()) | |
357 | } | |
358 | } | |
359 | ||
94222f64 | 360 | impl<'tcx> Key for (ty::PolyTraitRef<'tcx>, ty::PolyTraitRef<'tcx>) { |
9c376795 FG |
361 | type CacheSelector = DefaultCacheSelector<Self>; |
362 | ||
94222f64 XL |
363 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
364 | tcx.def_span(self.0.def_id()) | |
365 | } | |
366 | } | |
367 | ||
ba9703b0 | 368 | impl<'tcx> Key for GenericArg<'tcx> { |
9c376795 FG |
369 | type CacheSelector = DefaultCacheSelector<Self>; |
370 | ||
ba9703b0 XL |
371 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
372 | DUMMY_SP | |
373 | } | |
374 | } | |
375 | ||
cdc7bbd5 | 376 | impl<'tcx> Key for mir::ConstantKind<'tcx> { |
9c376795 FG |
377 | type CacheSelector = DefaultCacheSelector<Self>; |
378 | ||
cdc7bbd5 XL |
379 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
380 | DUMMY_SP | |
381 | } | |
382 | } | |
383 | ||
5099ac24 | 384 | impl<'tcx> Key for ty::Const<'tcx> { |
9c376795 FG |
385 | type CacheSelector = DefaultCacheSelector<Self>; |
386 | ||
dc9dc135 | 387 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
94b46f34 XL |
388 | DUMMY_SP |
389 | } | |
390 | } | |
391 | ||
ea8adc8c | 392 | impl<'tcx> Key for Ty<'tcx> { |
9c376795 FG |
393 | type CacheSelector = DefaultCacheSelector<Self>; |
394 | ||
064997fb FG |
395 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
396 | DUMMY_SP | |
397 | } | |
353b0b11 | 398 | |
2b03887a FG |
399 | fn ty_adt_id(&self) -> Option<DefId> { |
400 | match self.kind() { | |
401 | ty::Adt(adt, _) => Some(adt.did()), | |
402 | _ => None, | |
403 | } | |
404 | } | |
064997fb FG |
405 | } |
406 | ||
407 | impl<'tcx> Key for TyAndLayout<'tcx> { | |
9c376795 FG |
408 | type CacheSelector = DefaultCacheSelector<Self>; |
409 | ||
94222f64 XL |
410 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
411 | DUMMY_SP | |
412 | } | |
413 | } | |
414 | ||
415 | impl<'tcx> Key for (Ty<'tcx>, Ty<'tcx>) { | |
9c376795 FG |
416 | type CacheSelector = DefaultCacheSelector<Self>; |
417 | ||
dc9dc135 | 418 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
419 | DUMMY_SP |
420 | } | |
421 | } | |
422 | ||
3dfed10e | 423 | impl<'tcx> Key for &'tcx ty::List<ty::Predicate<'tcx>> { |
9c376795 FG |
424 | type CacheSelector = DefaultCacheSelector<Self>; |
425 | ||
3dfed10e XL |
426 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
427 | DUMMY_SP | |
428 | } | |
429 | } | |
430 | ||
83c7162d | 431 | impl<'tcx> Key for ty::ParamEnv<'tcx> { |
9c376795 FG |
432 | type CacheSelector = DefaultCacheSelector<Self>; |
433 | ||
dc9dc135 | 434 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
83c7162d XL |
435 | DUMMY_SP |
436 | } | |
437 | } | |
438 | ||
ea8adc8c | 439 | impl<'tcx, T: Key> Key for ty::ParamEnvAnd<'tcx, T> { |
9c376795 FG |
440 | type CacheSelector = DefaultCacheSelector<Self>; |
441 | ||
dc9dc135 | 442 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
443 | self.value.default_span(tcx) |
444 | } | |
445 | } | |
446 | ||
e74abb32 | 447 | impl Key for Symbol { |
9c376795 FG |
448 | type CacheSelector = DefaultCacheSelector<Self>; |
449 | ||
dc9dc135 | 450 | fn default_span(&self, _tcx: TyCtxt<'_>) -> Span { |
ea8adc8c XL |
451 | DUMMY_SP |
452 | } | |
453 | } | |
0531ce1d | 454 | |
04454e1e | 455 | impl Key for Option<Symbol> { |
9c376795 FG |
456 | type CacheSelector = DefaultCacheSelector<Self>; |
457 | ||
04454e1e FG |
458 | fn default_span(&self, _tcx: TyCtxt<'_>) -> Span { |
459 | DUMMY_SP | |
460 | } | |
461 | } | |
462 | ||
8faf50e0 XL |
463 | /// Canonical query goals correspond to abstract trait operations that |
464 | /// are not tied to any crate in particular. | |
353b0b11 | 465 | impl<'tcx, T: Clone> Key for Canonical<'tcx, T> { |
9c376795 FG |
466 | type CacheSelector = DefaultCacheSelector<Self>; |
467 | ||
e74abb32 XL |
468 | fn default_span(&self, _tcx: TyCtxt<'_>) -> Span { |
469 | DUMMY_SP | |
470 | } | |
471 | } | |
472 | ||
473 | impl Key for (Symbol, u32, u32) { | |
9c376795 FG |
474 | type CacheSelector = DefaultCacheSelector<Self>; |
475 | ||
dc9dc135 | 476 | fn default_span(&self, _tcx: TyCtxt<'_>) -> Span { |
83c7162d XL |
477 | DUMMY_SP |
478 | } | |
479 | } | |
ba9703b0 | 480 | |
f9f354fc | 481 | impl<'tcx> Key for (DefId, Ty<'tcx>, SubstsRef<'tcx>, ty::ParamEnv<'tcx>) { |
9c376795 FG |
482 | type CacheSelector = DefaultCacheSelector<Self>; |
483 | ||
136023e0 XL |
484 | fn default_span(&self, _tcx: TyCtxt<'_>) -> Span { |
485 | DUMMY_SP | |
486 | } | |
487 | } | |
488 | ||
489 | impl<'tcx> Key for (ty::Predicate<'tcx>, traits::WellFormedLoc) { | |
9c376795 FG |
490 | type CacheSelector = DefaultCacheSelector<Self>; |
491 | ||
f9f354fc XL |
492 | fn default_span(&self, _tcx: TyCtxt<'_>) -> Span { |
493 | DUMMY_SP | |
ba9703b0 XL |
494 | } |
495 | } | |
c295e0f8 XL |
496 | |
497 | impl<'tcx> Key for (ty::PolyFnSig<'tcx>, &'tcx ty::List<Ty<'tcx>>) { | |
9c376795 FG |
498 | type CacheSelector = DefaultCacheSelector<Self>; |
499 | ||
c295e0f8 XL |
500 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
501 | DUMMY_SP | |
502 | } | |
503 | } | |
504 | ||
505 | impl<'tcx> Key for (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>) { | |
9c376795 FG |
506 | type CacheSelector = DefaultCacheSelector<Self>; |
507 | ||
c295e0f8 XL |
508 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
509 | self.0.default_span(tcx) | |
510 | } | |
511 | } | |
04454e1e FG |
512 | |
513 | impl<'tcx> Key for (Ty<'tcx>, ty::ValTree<'tcx>) { | |
9c376795 FG |
514 | type CacheSelector = DefaultCacheSelector<Self>; |
515 | ||
04454e1e FG |
516 | fn default_span(&self, _: TyCtxt<'_>) -> Span { |
517 | DUMMY_SP | |
518 | } | |
519 | } | |
2b03887a FG |
520 | |
521 | impl Key for HirId { | |
9c376795 FG |
522 | type CacheSelector = DefaultCacheSelector<Self>; |
523 | ||
2b03887a FG |
524 | fn default_span(&self, tcx: TyCtxt<'_>) -> Span { |
525 | tcx.hir().span(*self) | |
526 | } | |
527 | ||
528 | #[inline(always)] | |
529 | fn key_as_def_id(&self) -> Option<DefId> { | |
530 | None | |
531 | } | |
532 | } | |
9ffffee4 FG |
533 | |
534 | impl<'tcx> Key for (ValidityRequirement, ty::ParamEnvAnd<'tcx, Ty<'tcx>>) { | |
535 | type CacheSelector = DefaultCacheSelector<Self>; | |
536 | ||
537 | // Just forward to `Ty<'tcx>` | |
9ffffee4 FG |
538 | |
539 | fn default_span(&self, _: TyCtxt<'_>) -> Span { | |
540 | DUMMY_SP | |
541 | } | |
542 | ||
543 | fn ty_adt_id(&self) -> Option<DefId> { | |
544 | match self.1.value.kind() { | |
545 | ty::Adt(adt, _) => Some(adt.did()), | |
546 | _ => None, | |
547 | } | |
548 | } | |
549 | } |