1#![allow(unused_parens)]
8
9use std::ffi::OsStr;
10use std::mem;
11use std::path::PathBuf;
12use std::sync::Arc;
13
14use rustc_arena::TypedArena;
15use rustc_ast::expand::StrippedCfgItem;
16use rustc_ast::expand::allocator::AllocatorKind;
17use rustc_data_structures::fingerprint::Fingerprint;
18use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
19use rustc_data_structures::sorted_map::SortedMap;
20use rustc_data_structures::steal::Steal;
21use rustc_data_structures::svh::Svh;
22use rustc_data_structures::unord::{UnordMap, UnordSet};
23use rustc_errors::ErrorGuaranteed;
24use rustc_hir::def::{DefKind, DocLinkResMap};
25use rustc_hir::def_id::{
26 CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap, LocalDefIdSet, LocalModDefId,
27};
28use rustc_hir::lang_items::{LangItem, LanguageItems};
29use rustc_hir::{Crate, ItemLocalId, ItemLocalMap, PreciseCapturingArgKind, TraitCandidate};
30use rustc_index::IndexVec;
31use rustc_lint_defs::LintId;
32use rustc_macros::rustc_queries;
33use rustc_query_system::ich::StableHashingContext;
34use rustc_query_system::query::{
35 QueryCache, QueryMode, QueryStackDeferred, QueryState, try_get_cached,
36};
37use rustc_session::Limits;
38use rustc_session::config::{EntryFnType, OptLevel, OutputFilenames, SymbolManglingVersion};
39use rustc_session::cstore::{
40 CrateDepKind, CrateSource, ExternCrate, ForeignModule, LinkagePreference, NativeLib,
41};
42use rustc_session::lint::LintExpectationId;
43use rustc_span::def_id::LOCAL_CRATE;
44use rustc_span::source_map::Spanned;
45use rustc_span::{DUMMY_SP, Span, Symbol};
46use rustc_target::spec::PanicStrategy;
47use {rustc_abi as abi, rustc_ast as ast, rustc_attr_data_structures as attr, rustc_hir as hir};
48
49use crate::infer::canonical::{self, Canonical};
50use crate::lint::LintExpectation;
51use crate::metadata::ModChild;
52use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
53use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
54use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
55use crate::middle::lib_features::LibFeatures;
56use crate::middle::privacy::EffectiveVisibilities;
57use crate::middle::resolve_bound_vars::{ObjectLifetimeDefault, ResolveBoundVars, ResolvedArg};
58use crate::middle::stability::{self, DeprecationEntry};
59use crate::mir::interpret::{
60 EvalStaticInitializerRawResult, EvalToAllocationRawResult, EvalToConstValueResult,
61 EvalToValTreeResult, GlobalId, LitToConstInput,
62};
63use crate::mir::mono::{CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions};
64use crate::query::erase::{Erase, erase, restore};
65use crate::query::plumbing::{
66 CyclePlaceholder, DynamicQuery, query_ensure, query_ensure_error_guaranteed, query_get_at,
67};
68use crate::traits::query::{
69 CanonicalAliasGoal, CanonicalDropckOutlivesGoal, CanonicalImpliedOutlivesBoundsGoal,
70 CanonicalPredicateGoal, CanonicalTyGoal, CanonicalTypeOpAscribeUserTypeGoal,
71 CanonicalTypeOpNormalizeGoal, CanonicalTypeOpProvePredicateGoal, DropckConstraint,
72 DropckOutlivesResult, MethodAutoderefStepsResult, NoSolution, NormalizationResult,
73 OutlivesBound,
74};
75use crate::traits::{
76 CodegenObligationError, DynCompatibilityViolation, EvaluationResult, ImplSource,
77 ObligationCause, OverflowError, WellFormedLoc, specialization_graph,
78};
79use crate::ty::fast_reject::SimplifiedType;
80use crate::ty::layout::ValidityRequirement;
81use crate::ty::print::{PrintTraitRefExt, describe_as_module};
82use crate::ty::util::AlwaysRequiresDrop;
83use crate::ty::{
84 self, CrateInherentImpls, GenericArg, GenericArgsRef, PseudoCanonicalInput, Ty, TyCtxt,
85 TyCtxtFeed,
86};
87use crate::{dep_graph, mir, thir};
88
89mod arena_cached;
90pub mod erase;
91mod keys;
92pub use keys::{AsLocalKey, Key, LocalCrate};
93pub mod on_disk_cache;
94#[macro_use]
95pub mod plumbing;
96pub use plumbing::{IntoQueryParam, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk};
97
98rustc_queries! {
110 query trigger_delayed_bug(key: DefId) {
112 desc { "triggering a delayed bug for testing incremental" }
113 }
114
115 query registered_tools(_: ()) -> &'tcx ty::RegisteredTools {
117 arena_cache
118 desc { "compute registered tools for crate" }
119 }
120
121 query early_lint_checks(_: ()) {
122 desc { "perform lints prior to AST lowering" }
123 }
124
125 query env_var_os(key: &'tcx OsStr) -> Option<&'tcx OsStr> {
135 eval_always
137 desc { "get the value of an environment variable" }
138 }
139
140 query resolutions(_: ()) -> &'tcx ty::ResolverGlobalCtxt {
141 no_hash
142 desc { "getting the resolver outputs" }
143 }
144
145 query resolver_for_lowering_raw(_: ()) -> (&'tcx Steal<(ty::ResolverAstLowering, Arc<ast::Crate>)>, &'tcx ty::ResolverGlobalCtxt) {
146 eval_always
147 no_hash
148 desc { "getting the resolver for lowering" }
149 }
150
151 query source_span(key: LocalDefId) -> Span {
157 eval_always
159 desc { "getting the source span" }
160 }
161
162 query hir_crate(key: ()) -> &'tcx Crate<'tcx> {
170 arena_cache
171 eval_always
172 desc { "getting the crate HIR" }
173 }
174
175 query hir_crate_items(_: ()) -> &'tcx rustc_middle::hir::ModuleItems {
177 arena_cache
178 eval_always
179 desc { "getting HIR crate items" }
180 }
181
182 query hir_module_items(key: LocalModDefId) -> &'tcx rustc_middle::hir::ModuleItems {
187 arena_cache
188 desc { |tcx| "getting HIR module items in `{}`", tcx.def_path_str(key) }
189 cache_on_disk_if { true }
190 }
191
192 query local_def_id_to_hir_id(key: LocalDefId) -> hir::HirId {
194 desc { |tcx| "getting HIR ID of `{}`", tcx.def_path_str(key) }
195 feedable
196 }
197
198 query hir_owner_parent(key: hir::OwnerId) -> hir::HirId {
203 desc { |tcx| "getting HIR parent of `{}`", tcx.def_path_str(key) }
204 }
205
206 query opt_hir_owner_nodes(key: LocalDefId) -> Option<&'tcx hir::OwnerNodes<'tcx>> {
211 desc { |tcx| "getting HIR owner items in `{}`", tcx.def_path_str(key) }
212 feedable
213 }
214
215 query hir_attr_map(key: hir::OwnerId) -> &'tcx hir::AttributeMap<'tcx> {
220 desc { |tcx| "getting HIR owner attributes in `{}`", tcx.def_path_str(key) }
221 feedable
222 }
223
224 query const_param_default(param: DefId) -> ty::EarlyBinder<'tcx, ty::Const<'tcx>> {
228 desc { |tcx| "computing the default for const parameter `{}`", tcx.def_path_str(param) }
229 cache_on_disk_if { param.is_local() }
230 separate_provide_extern
231 }
232
233 query type_of(key: DefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
252 desc { |tcx|
253 "{action} `{path}`",
254 action = match tcx.def_kind(key) {
255 DefKind::TyAlias => "expanding type alias",
256 DefKind::TraitAlias => "expanding trait alias",
257 _ => "computing type of",
258 },
259 path = tcx.def_path_str(key),
260 }
261 cache_on_disk_if { key.is_local() }
262 separate_provide_extern
263 feedable
264 }
265
266 query type_of_opaque(key: DefId) -> Result<ty::EarlyBinder<'tcx, Ty<'tcx>>, CyclePlaceholder> {
277 desc { |tcx|
278 "computing type of opaque `{path}`",
279 path = tcx.def_path_str(key),
280 }
281 cycle_stash
282 }
283 query type_of_opaque_hir_typeck(key: LocalDefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
284 desc { |tcx|
285 "computing type of opaque `{path}` via HIR typeck",
286 path = tcx.def_path_str(key),
287 }
288 }
289
290 query type_alias_is_lazy(key: DefId) -> bool {
304 desc { |tcx|
305 "computing whether the type alias `{path}` is lazy",
306 path = tcx.def_path_str(key),
307 }
308 separate_provide_extern
309 }
310
311 query collect_return_position_impl_trait_in_trait_tys(key: DefId)
312 -> Result<&'tcx DefIdMap<ty::EarlyBinder<'tcx, Ty<'tcx>>>, ErrorGuaranteed>
313 {
314 desc { "comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process" }
315 cache_on_disk_if { key.is_local() }
316 separate_provide_extern
317 }
318
319 query opaque_ty_origin(key: DefId) -> hir::OpaqueTyOrigin<DefId>
320 {
321 desc { "determine where the opaque originates from" }
322 separate_provide_extern
323 }
324
325 query unsizing_params_for_adt(key: DefId) -> &'tcx rustc_index::bit_set::DenseBitSet<u32>
326 {
327 arena_cache
328 desc { |tcx|
329 "determining what parameters of `{}` can participate in unsizing",
330 tcx.def_path_str(key),
331 }
332 }
333
334 query analysis(key: ()) {
336 eval_always
337 desc { "running analysis passes on this crate" }
338 }
339
340 query check_expectations(key: Option<Symbol>) {
355 eval_always
356 desc { "checking lint expectations (RFC 2383)" }
357 }
358
359 query generics_of(key: DefId) -> &'tcx ty::Generics {
361 desc { |tcx| "computing generics of `{}`", tcx.def_path_str(key) }
362 arena_cache
363 cache_on_disk_if { key.is_local() }
364 separate_provide_extern
365 feedable
366 }
367
368 query predicates_of(key: DefId) -> ty::GenericPredicates<'tcx> {
376 desc { |tcx| "computing predicates of `{}`", tcx.def_path_str(key) }
377 cache_on_disk_if { key.is_local() }
378 feedable
379 }
380
381 query opaque_types_defined_by(
382 key: LocalDefId
383 ) -> &'tcx ty::List<LocalDefId> {
384 desc {
385 |tcx| "computing the opaque types defined by `{}`",
386 tcx.def_path_str(key.to_def_id())
387 }
388 }
389
390 query nested_bodies_within(
391 key: LocalDefId
392 ) -> &'tcx ty::List<LocalDefId> {
393 desc {
394 |tcx| "computing the coroutines defined within `{}`",
395 tcx.def_path_str(key.to_def_id())
396 }
397 }
398
399 query explicit_item_bounds(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
418 desc { |tcx| "finding item bounds for `{}`", tcx.def_path_str(key) }
419 cache_on_disk_if { key.is_local() }
420 separate_provide_extern
421 feedable
422 }
423
424 query explicit_item_self_bounds(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
431 desc { |tcx| "finding item bounds for `{}`", tcx.def_path_str(key) }
432 cache_on_disk_if { key.is_local() }
433 separate_provide_extern
434 feedable
435 }
436
437 query item_bounds(key: DefId) -> ty::EarlyBinder<'tcx, ty::Clauses<'tcx>> {
461 desc { |tcx| "elaborating item bounds for `{}`", tcx.def_path_str(key) }
462 }
463
464 query item_self_bounds(key: DefId) -> ty::EarlyBinder<'tcx, ty::Clauses<'tcx>> {
465 desc { |tcx| "elaborating item assumptions for `{}`", tcx.def_path_str(key) }
466 }
467
468 query item_non_self_bounds(key: DefId) -> ty::EarlyBinder<'tcx, ty::Clauses<'tcx>> {
469 desc { |tcx| "elaborating item assumptions for `{}`", tcx.def_path_str(key) }
470 }
471
472 query impl_super_outlives(key: DefId) -> ty::EarlyBinder<'tcx, ty::Clauses<'tcx>> {
473 desc { |tcx| "elaborating supertrait outlives for trait of `{}`", tcx.def_path_str(key) }
474 }
475
476 query native_libraries(_: CrateNum) -> &'tcx Vec<NativeLib> {
481 arena_cache
482 desc { "looking up the native libraries of a linked crate" }
483 separate_provide_extern
484 }
485
486 query shallow_lint_levels_on(key: hir::OwnerId) -> &'tcx rustc_middle::lint::ShallowLintLevelMap {
487 arena_cache
488 desc { |tcx| "looking up lint levels for `{}`", tcx.def_path_str(key) }
489 }
490
491 query lint_expectations(_: ()) -> &'tcx Vec<(LintExpectationId, LintExpectation)> {
492 arena_cache
493 desc { "computing `#[expect]`ed lints in this crate" }
494 }
495
496 query lints_that_dont_need_to_run(_: ()) -> &'tcx UnordSet<LintId> {
497 arena_cache
498 desc { "Computing all lints that are explicitly enabled or with a default level greater than Allow" }
499 }
500
501 query expn_that_defined(key: DefId) -> rustc_span::ExpnId {
502 desc { |tcx| "getting the expansion that defined `{}`", tcx.def_path_str(key) }
503 separate_provide_extern
504 }
505
506 query is_panic_runtime(_: CrateNum) -> bool {
507 fatal_cycle
508 desc { "checking if the crate is_panic_runtime" }
509 separate_provide_extern
510 }
511
512 query representability(_: LocalDefId) -> rustc_middle::ty::Representability {
514 desc { "checking if `{}` is representable", tcx.def_path_str(key) }
515 cycle_delay_bug
517 anon
521 }
522
523 query representability_adt_ty(_: Ty<'tcx>) -> rustc_middle::ty::Representability {
525 desc { "checking if `{}` is representable", key }
526 cycle_delay_bug
527 anon
528 }
529
530 query params_in_repr(key: DefId) -> &'tcx rustc_index::bit_set::DenseBitSet<u32> {
532 desc { "finding type parameters in the representation" }
533 arena_cache
534 no_hash
535 separate_provide_extern
536 }
537
538 query thir_body(key: LocalDefId) -> Result<(&'tcx Steal<thir::Thir<'tcx>>, thir::ExprId), ErrorGuaranteed> {
541 no_hash
543 desc { |tcx| "building THIR for `{}`", tcx.def_path_str(key) }
544 }
545
546 query mir_keys(_: ()) -> &'tcx rustc_data_structures::fx::FxIndexSet<LocalDefId> {
550 arena_cache
551 desc { "getting a list of all mir_keys" }
552 }
553
554 query mir_const_qualif(key: DefId) -> mir::ConstQualifs {
558 desc { |tcx| "const checking `{}`", tcx.def_path_str(key) }
559 cache_on_disk_if { key.is_local() }
560 separate_provide_extern
561 }
562
563 query mir_built(key: LocalDefId) -> &'tcx Steal<mir::Body<'tcx>> {
569 desc { |tcx| "building MIR for `{}`", tcx.def_path_str(key) }
570 feedable
571 }
572
573 query thir_abstract_const(
575 key: DefId
576 ) -> Result<Option<ty::EarlyBinder<'tcx, ty::Const<'tcx>>>, ErrorGuaranteed> {
577 desc {
578 |tcx| "building an abstract representation for `{}`", tcx.def_path_str(key),
579 }
580 separate_provide_extern
581 }
582
583 query mir_drops_elaborated_and_const_checked(key: LocalDefId) -> &'tcx Steal<mir::Body<'tcx>> {
584 no_hash
585 desc { |tcx| "elaborating drops for `{}`", tcx.def_path_str(key) }
586 }
587
588 query mir_for_ctfe(
589 key: DefId
590 ) -> &'tcx mir::Body<'tcx> {
591 desc { |tcx| "caching mir of `{}` for CTFE", tcx.def_path_str(key) }
592 cache_on_disk_if { key.is_local() }
593 separate_provide_extern
594 }
595
596 query mir_promoted(key: LocalDefId) -> (
597 &'tcx Steal<mir::Body<'tcx>>,
598 &'tcx Steal<IndexVec<mir::Promoted, mir::Body<'tcx>>>
599 ) {
600 no_hash
601 desc { |tcx| "promoting constants in MIR for `{}`", tcx.def_path_str(key) }
602 }
603
604 query closure_typeinfo(key: LocalDefId) -> ty::ClosureTypeInfo<'tcx> {
605 desc {
606 |tcx| "finding symbols for captures of closure `{}`",
607 tcx.def_path_str(key)
608 }
609 }
610
611 query closure_saved_names_of_captured_variables(def_id: DefId) -> &'tcx IndexVec<abi::FieldIdx, Symbol> {
619 arena_cache
620 desc { |tcx| "computing debuginfo for closure `{}`", tcx.def_path_str(def_id) }
621 separate_provide_extern
622 }
623
624 query mir_coroutine_witnesses(key: DefId) -> Option<&'tcx mir::CoroutineLayout<'tcx>> {
625 arena_cache
626 desc { |tcx| "coroutine witness types for `{}`", tcx.def_path_str(key) }
627 cache_on_disk_if { key.is_local() }
628 separate_provide_extern
629 }
630
631 query check_coroutine_obligations(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
632 desc { |tcx| "verify auto trait bounds for coroutine interior type `{}`", tcx.def_path_str(key) }
633 return_result_from_ensure_ok
634 }
635
636 query optimized_mir(key: DefId) -> &'tcx mir::Body<'tcx> {
639 desc { |tcx| "optimizing MIR for `{}`", tcx.def_path_str(key) }
640 cache_on_disk_if { key.is_local() }
641 separate_provide_extern
642 }
643
644 query coverage_attr_on(key: LocalDefId) -> bool {
650 desc { |tcx| "checking for `#[coverage(..)]` on `{}`", tcx.def_path_str(key) }
651 feedable
652 }
653
654 query coverage_ids_info(key: ty::InstanceKind<'tcx>) -> Option<&'tcx mir::coverage::CoverageIdsInfo> {
667 desc { |tcx| "retrieving coverage IDs info from MIR for `{}`", tcx.def_path_str(key.def_id()) }
668 arena_cache
669 }
670
671 query promoted_mir(key: DefId) -> &'tcx IndexVec<mir::Promoted, mir::Body<'tcx>> {
677 desc { |tcx| "optimizing promoted MIR for `{}`", tcx.def_path_str(key) }
678 cache_on_disk_if { key.is_local() }
679 separate_provide_extern
680 }
681
682 query erase_regions_ty(ty: Ty<'tcx>) -> Ty<'tcx> {
686 anon
693 desc { "erasing regions from `{}`", ty }
694 }
695
696 query wasm_import_module_map(_: CrateNum) -> &'tcx DefIdMap<String> {
697 arena_cache
698 desc { "getting wasm import module map" }
699 }
700
701 query trait_explicit_predicates_and_bounds(key: LocalDefId) -> ty::GenericPredicates<'tcx> {
723 desc { |tcx| "computing explicit predicates of trait `{}`", tcx.def_path_str(key) }
724 }
725
726 query explicit_predicates_of(key: DefId) -> ty::GenericPredicates<'tcx> {
732 desc { |tcx| "computing explicit predicates of `{}`", tcx.def_path_str(key) }
733 cache_on_disk_if { key.is_local() }
734 separate_provide_extern
735 feedable
736 }
737
738 query inferred_outlives_of(key: DefId) -> &'tcx [(ty::Clause<'tcx>, Span)] {
745 desc { |tcx| "computing inferred outlives-predicates of `{}`", tcx.def_path_str(key) }
746 cache_on_disk_if { key.is_local() }
747 separate_provide_extern
748 feedable
749 }
750
751 query explicit_super_predicates_of(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
759 desc { |tcx| "computing the super predicates of `{}`", tcx.def_path_str(key) }
760 cache_on_disk_if { key.is_local() }
761 separate_provide_extern
762 }
763
764 query explicit_implied_predicates_of(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
771 desc { |tcx| "computing the implied predicates of `{}`", tcx.def_path_str(key) }
772 cache_on_disk_if { key.is_local() }
773 separate_provide_extern
774 }
775
776 query explicit_supertraits_containing_assoc_item(
780 key: (DefId, rustc_span::Ident)
781 ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
782 desc { |tcx| "computing the super traits of `{}` with associated type name `{}`",
783 tcx.def_path_str(key.0),
784 key.1
785 }
786 }
787
788 query const_conditions(
798 key: DefId
799 ) -> ty::ConstConditions<'tcx> {
800 desc { |tcx| "computing the conditions for `{}` to be considered const",
801 tcx.def_path_str(key)
802 }
803 separate_provide_extern
804 }
805
806 query explicit_implied_const_bounds(
812 key: DefId
813 ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::PolyTraitRef<'tcx>, Span)]> {
814 desc { |tcx| "computing the implied `~const` bounds for `{}`",
815 tcx.def_path_str(key)
816 }
817 separate_provide_extern
818 }
819
820 query type_param_predicates(
823 key: (LocalDefId, LocalDefId, rustc_span::Ident)
824 ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
825 desc { |tcx| "computing the bounds for type parameter `{}`", tcx.hir_ty_param_name(key.1) }
826 }
827
828 query trait_def(key: DefId) -> &'tcx ty::TraitDef {
829 desc { |tcx| "computing trait definition for `{}`", tcx.def_path_str(key) }
830 arena_cache
831 cache_on_disk_if { key.is_local() }
832 separate_provide_extern
833 }
834 query adt_def(key: DefId) -> ty::AdtDef<'tcx> {
835 desc { |tcx| "computing ADT definition for `{}`", tcx.def_path_str(key) }
836 cache_on_disk_if { key.is_local() }
837 separate_provide_extern
838 }
839 query adt_destructor(key: DefId) -> Option<ty::Destructor> {
840 desc { |tcx| "computing `Drop` impl for `{}`", tcx.def_path_str(key) }
841 cache_on_disk_if { key.is_local() }
842 separate_provide_extern
843 }
844 query adt_async_destructor(key: DefId) -> Option<ty::AsyncDestructor> {
845 desc { |tcx| "computing `AsyncDrop` impl for `{}`", tcx.def_path_str(key) }
846 cache_on_disk_if { key.is_local() }
847 separate_provide_extern
848 }
849
850 query adt_sized_constraint(key: DefId) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
851 desc { |tcx| "computing the `Sized` constraint for `{}`", tcx.def_path_str(key) }
852 }
853
854 query adt_dtorck_constraint(
855 key: DefId
856 ) -> &'tcx DropckConstraint<'tcx> {
857 desc { |tcx| "computing drop-check constraints for `{}`", tcx.def_path_str(key) }
858 }
859
860 query constness(key: DefId) -> hir::Constness {
882 desc { |tcx| "checking if item is const: `{}`", tcx.def_path_str(key) }
883 separate_provide_extern
884 feedable
885 }
886
887 query asyncness(key: DefId) -> ty::Asyncness {
888 desc { |tcx| "checking if the function is async: `{}`", tcx.def_path_str(key) }
889 separate_provide_extern
890 }
891
892 query is_promotable_const_fn(key: DefId) -> bool {
900 desc { |tcx| "checking if item is promotable: `{}`", tcx.def_path_str(key) }
901 }
902
903 query coroutine_by_move_body_def_id(def_id: DefId) -> DefId {
910 desc { |tcx| "looking up the coroutine by-move body for `{}`", tcx.def_path_str(def_id) }
911 separate_provide_extern
912 }
913
914 query coroutine_kind(def_id: DefId) -> Option<hir::CoroutineKind> {
916 desc { |tcx| "looking up coroutine kind of `{}`", tcx.def_path_str(def_id) }
917 separate_provide_extern
918 feedable
919 }
920
921 query coroutine_for_closure(def_id: DefId) -> DefId {
922 desc { |_tcx| "Given a coroutine-closure def id, return the def id of the coroutine returned by it" }
923 separate_provide_extern
924 }
925
926 query coroutine_hidden_types(
927 def_id: DefId
928 ) -> ty::EarlyBinder<'tcx, ty::Binder<'tcx, ty::CoroutineWitnessTypes<TyCtxt<'tcx>>>> {
929 desc { "looking up the hidden types stored across await points in a coroutine" }
930 }
931
932 query crate_variances(_: ()) -> &'tcx ty::CrateVariancesMap<'tcx> {
940 arena_cache
941 desc { "computing the variances for items in this crate" }
942 }
943
944 query variances_of(def_id: DefId) -> &'tcx [ty::Variance] {
952 desc { |tcx| "computing the variances of `{}`", tcx.def_path_str(def_id) }
953 cache_on_disk_if { def_id.is_local() }
954 separate_provide_extern
955 cycle_delay_bug
956 }
957
958 query inferred_outlives_crate(_: ()) -> &'tcx ty::CratePredicatesMap<'tcx> {
966 arena_cache
967 desc { "computing the inferred outlives-predicates for items in this crate" }
968 }
969
970 query associated_item_def_ids(key: DefId) -> &'tcx [DefId] {
973 desc { |tcx| "collecting associated items or fields of `{}`", tcx.def_path_str(key) }
974 cache_on_disk_if { key.is_local() }
975 separate_provide_extern
976 }
977
978 query associated_item(key: DefId) -> ty::AssocItem {
980 desc { |tcx| "computing associated item data for `{}`", tcx.def_path_str(key) }
981 cache_on_disk_if { key.is_local() }
982 separate_provide_extern
983 feedable
984 }
985
986 query associated_items(key: DefId) -> &'tcx ty::AssocItems {
988 arena_cache
989 desc { |tcx| "collecting associated items of `{}`", tcx.def_path_str(key) }
990 }
991
992 query impl_item_implementor_ids(impl_id: DefId) -> &'tcx DefIdMap<DefId> {
1014 arena_cache
1015 desc { |tcx| "comparing impl items against trait for `{}`", tcx.def_path_str(impl_id) }
1016 }
1017
1018 query associated_types_for_impl_traits_in_associated_fn(fn_def_id: DefId) -> &'tcx [DefId] {
1025 desc { |tcx| "creating associated items for opaque types returned by `{}`", tcx.def_path_str(fn_def_id) }
1026 cache_on_disk_if { fn_def_id.is_local() }
1027 separate_provide_extern
1028 }
1029
1030 query associated_type_for_impl_trait_in_trait(opaque_ty_def_id: LocalDefId) -> LocalDefId {
1033 desc { |tcx| "creating the associated item corresponding to the opaque type `{}`", tcx.def_path_str(opaque_ty_def_id.to_def_id()) }
1034 cache_on_disk_if { true }
1035 }
1036
1037 query impl_trait_header(impl_id: DefId) -> Option<ty::ImplTraitHeader<'tcx>> {
1040 desc { |tcx| "computing trait implemented by `{}`", tcx.def_path_str(impl_id) }
1041 cache_on_disk_if { impl_id.is_local() }
1042 separate_provide_extern
1043 }
1044
1045 query impl_self_is_guaranteed_unsized(impl_def_id: DefId) -> bool {
1049 desc { |tcx| "computing whether `{}` has a guaranteed unsized self type", tcx.def_path_str(impl_def_id) }
1050 }
1051
1052 query inherent_impls(key: DefId) -> &'tcx [DefId] {
1056 desc { |tcx| "collecting inherent impls for `{}`", tcx.def_path_str(key) }
1057 cache_on_disk_if { key.is_local() }
1058 separate_provide_extern
1059 }
1060
1061 query incoherent_impls(key: SimplifiedType) -> &'tcx [DefId] {
1062 desc { |tcx| "collecting all inherent impls for `{:?}`", key }
1063 }
1064
1065 query check_unsafety(key: LocalDefId) {
1067 desc { |tcx| "unsafety-checking `{}`", tcx.def_path_str(key) }
1068 }
1069
1070 query check_tail_calls(key: LocalDefId) -> Result<(), rustc_errors::ErrorGuaranteed> {
1072 desc { |tcx| "tail-call-checking `{}`", tcx.def_path_str(key) }
1073 return_result_from_ensure_ok
1074 }
1075
1076 query assumed_wf_types(key: LocalDefId) -> &'tcx [(Ty<'tcx>, Span)] {
1081 desc { |tcx| "computing the implied bounds of `{}`", tcx.def_path_str(key) }
1082 }
1083
1084 query assumed_wf_types_for_rpitit(key: DefId) -> &'tcx [(Ty<'tcx>, Span)] {
1087 desc { |tcx| "computing the implied bounds of `{}`", tcx.def_path_str(key) }
1088 separate_provide_extern
1089 }
1090
1091 query fn_sig(key: DefId) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
1093 desc { |tcx| "computing function signature of `{}`", tcx.def_path_str(key) }
1094 cache_on_disk_if { key.is_local() }
1095 separate_provide_extern
1096 cycle_delay_bug
1097 }
1098
1099 query lint_mod(key: LocalModDefId) {
1101 desc { |tcx| "linting {}", describe_as_module(key, tcx) }
1102 }
1103
1104 query check_unused_traits(_: ()) {
1105 desc { "checking unused trait imports in crate" }
1106 }
1107
1108 query check_mod_attrs(key: LocalModDefId) {
1110 desc { |tcx| "checking attributes in {}", describe_as_module(key, tcx) }
1111 }
1112
1113 query check_mod_unstable_api_usage(key: LocalModDefId) {
1115 desc { |tcx| "checking for unstable API usage in {}", describe_as_module(key, tcx) }
1116 }
1117
1118 query check_mod_loops(key: LocalModDefId) {
1120 desc { |tcx| "checking loops in {}", describe_as_module(key, tcx) }
1121 }
1122
1123 query check_mod_privacy(key: LocalModDefId) {
1124 desc { |tcx| "checking privacy in {}", describe_as_module(key.to_local_def_id(), tcx) }
1125 }
1126
1127 query check_liveness(key: LocalDefId) {
1128 desc { |tcx| "checking liveness of variables in `{}`", tcx.def_path_str(key) }
1129 }
1130
1131 query live_symbols_and_ignored_derived_traits(_: ()) -> &'tcx (
1136 LocalDefIdSet,
1137 LocalDefIdMap<FxIndexSet<(DefId, DefId)>>
1138 ) {
1139 arena_cache
1140 desc { "finding live symbols in crate" }
1141 }
1142
1143 query check_mod_deathness(key: LocalModDefId) {
1144 desc { |tcx| "checking deathness of variables in {}", describe_as_module(key, tcx) }
1145 }
1146
1147 query check_type_wf(key: ()) -> Result<(), ErrorGuaranteed> {
1148 desc { "checking that types are well-formed" }
1149 return_result_from_ensure_ok
1150 }
1151
1152 query coerce_unsized_info(key: DefId) -> Result<ty::adjustment::CoerceUnsizedInfo, ErrorGuaranteed> {
1154 desc { |tcx| "computing CoerceUnsized info for `{}`", tcx.def_path_str(key) }
1155 cache_on_disk_if { key.is_local() }
1156 separate_provide_extern
1157 return_result_from_ensure_ok
1158 }
1159
1160 query typeck(key: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
1161 desc { |tcx| "type-checking `{}`", tcx.def_path_str(key) }
1162 cache_on_disk_if(tcx) { !tcx.is_typeck_child(key.to_def_id()) }
1163 }
1164
1165 query used_trait_imports(key: LocalDefId) -> &'tcx UnordSet<LocalDefId> {
1166 desc { |tcx| "finding used_trait_imports `{}`", tcx.def_path_str(key) }
1167 cache_on_disk_if { true }
1168 }
1169
1170 query coherent_trait(def_id: DefId) -> Result<(), ErrorGuaranteed> {
1171 desc { |tcx| "coherence checking all impls of trait `{}`", tcx.def_path_str(def_id) }
1172 return_result_from_ensure_ok
1173 }
1174
1175 query mir_borrowck(key: LocalDefId) -> Result<&'tcx mir::ConcreteOpaqueTypes<'tcx>, ErrorGuaranteed> {
1178 desc { |tcx| "borrow-checking `{}`", tcx.def_path_str(key) }
1179 }
1180
1181 query crate_inherent_impls(k: ()) -> (&'tcx CrateInherentImpls, Result<(), ErrorGuaranteed>) {
1189 desc { "finding all inherent impls defined in crate" }
1190 }
1191
1192 query crate_inherent_impls_validity_check(_: ()) -> Result<(), ErrorGuaranteed> {
1200 desc { "check for inherent impls that should not be defined in crate" }
1201 return_result_from_ensure_ok
1202 }
1203
1204 query crate_inherent_impls_overlap_check(_: ()) -> Result<(), ErrorGuaranteed> {
1212 desc { "check for overlap between inherent impls defined in this crate" }
1213 return_result_from_ensure_ok
1214 }
1215
1216 query orphan_check_impl(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
1219 desc { |tcx|
1220 "checking whether impl `{}` follows the orphan rules",
1221 tcx.def_path_str(key),
1222 }
1223 return_result_from_ensure_ok
1224 }
1225
1226 query mir_callgraph_reachable(key: (ty::Instance<'tcx>, LocalDefId)) -> bool {
1229 fatal_cycle
1230 desc { |tcx|
1231 "computing if `{}` (transitively) calls `{}`",
1232 key.0,
1233 tcx.def_path_str(key.1),
1234 }
1235 }
1236
1237 query mir_inliner_callees(key: ty::InstanceKind<'tcx>) -> &'tcx [(DefId, GenericArgsRef<'tcx>)] {
1239 fatal_cycle
1240 desc { |tcx|
1241 "computing all local function calls in `{}`",
1242 tcx.def_path_str(key.def_id()),
1243 }
1244 }
1245
1246 query tag_for_variant(
1254 key: (Ty<'tcx>, abi::VariantIdx)
1255 ) -> Option<ty::ScalarInt> {
1256 desc { "computing variant tag for enum" }
1257 }
1258
1259 query eval_to_allocation_raw(key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>)
1268 -> EvalToAllocationRawResult<'tcx> {
1269 desc { |tcx|
1270 "const-evaluating + checking `{}`",
1271 key.value.display(tcx)
1272 }
1273 cache_on_disk_if { true }
1274 }
1275
1276 query eval_static_initializer(key: DefId) -> EvalStaticInitializerRawResult<'tcx> {
1278 desc { |tcx|
1279 "evaluating initializer of static `{}`",
1280 tcx.def_path_str(key)
1281 }
1282 cache_on_disk_if { key.is_local() }
1283 separate_provide_extern
1284 feedable
1285 }
1286
1287 query eval_to_const_value_raw(key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>)
1300 -> EvalToConstValueResult<'tcx> {
1301 desc { |tcx|
1302 "simplifying constant for the type system `{}`",
1303 key.value.display(tcx)
1304 }
1305 depth_limit
1306 cache_on_disk_if { true }
1307 }
1308
1309 query eval_to_valtree(
1312 key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>
1313 ) -> EvalToValTreeResult<'tcx> {
1314 desc { "evaluating type-level constant" }
1315 }
1316
1317 query valtree_to_const_val(key: ty::Value<'tcx>) -> mir::ConstValue<'tcx> {
1319 desc { "converting type-level constant value to MIR constant value"}
1320 }
1321
1322 query destructure_const(key: ty::Const<'tcx>) -> ty::DestructuredConst<'tcx> {
1325 desc { "destructuring type level constant"}
1326 }
1327
1328 query lit_to_const(
1330 key: LitToConstInput<'tcx>
1331 ) -> ty::Const<'tcx> {
1332 desc { "converting literal to const" }
1333 }
1334
1335 query check_match(key: LocalDefId) -> Result<(), rustc_errors::ErrorGuaranteed> {
1336 desc { |tcx| "match-checking `{}`", tcx.def_path_str(key) }
1337 return_result_from_ensure_ok
1338 }
1339
1340 query effective_visibilities(_: ()) -> &'tcx EffectiveVisibilities {
1342 eval_always
1343 desc { "checking effective visibilities" }
1344 }
1345 query check_private_in_public(_: ()) {
1346 eval_always
1347 desc { "checking for private elements in public interfaces" }
1348 }
1349
1350 query reachable_set(_: ()) -> &'tcx LocalDefIdSet {
1351 arena_cache
1352 desc { "reachability" }
1353 cache_on_disk_if { true }
1354 }
1355
1356 query region_scope_tree(def_id: DefId) -> &'tcx crate::middle::region::ScopeTree {
1359 desc { |tcx| "computing drop scopes for `{}`", tcx.def_path_str(def_id) }
1360 }
1361
1362 query mir_shims(key: ty::InstanceKind<'tcx>) -> &'tcx mir::Body<'tcx> {
1364 arena_cache
1365 desc {
1366 |tcx| "generating MIR shim for `{}`, instance={:?}",
1367 tcx.def_path_str(key.def_id()),
1368 key
1369 }
1370 }
1371
1372 query symbol_name(key: ty::Instance<'tcx>) -> ty::SymbolName<'tcx> {
1376 desc { "computing the symbol for `{}`", key }
1377 cache_on_disk_if { true }
1378 }
1379
1380 query def_kind(def_id: DefId) -> DefKind {
1381 desc { |tcx| "looking up definition kind of `{}`", tcx.def_path_str(def_id) }
1382 cache_on_disk_if { def_id.is_local() }
1383 separate_provide_extern
1384 feedable
1385 }
1386
1387 query def_span(def_id: DefId) -> Span {
1389 desc { |tcx| "looking up span for `{}`", tcx.def_path_str(def_id) }
1390 cache_on_disk_if { def_id.is_local() }
1391 separate_provide_extern
1392 feedable
1393 }
1394
1395 query def_ident_span(def_id: DefId) -> Option<Span> {
1397 desc { |tcx| "looking up span for `{}`'s identifier", tcx.def_path_str(def_id) }
1398 cache_on_disk_if { def_id.is_local() }
1399 separate_provide_extern
1400 feedable
1401 }
1402
1403 query lookup_stability(def_id: DefId) -> Option<attr::Stability> {
1404 desc { |tcx| "looking up stability of `{}`", tcx.def_path_str(def_id) }
1405 cache_on_disk_if { def_id.is_local() }
1406 separate_provide_extern
1407 }
1408
1409 query lookup_const_stability(def_id: DefId) -> Option<attr::ConstStability> {
1410 desc { |tcx| "looking up const stability of `{}`", tcx.def_path_str(def_id) }
1411 cache_on_disk_if { def_id.is_local() }
1412 separate_provide_extern
1413 }
1414
1415 query lookup_default_body_stability(def_id: DefId) -> Option<attr::DefaultBodyStability> {
1416 desc { |tcx| "looking up default body stability of `{}`", tcx.def_path_str(def_id) }
1417 separate_provide_extern
1418 }
1419
1420 query should_inherit_track_caller(def_id: DefId) -> bool {
1421 desc { |tcx| "computing should_inherit_track_caller of `{}`", tcx.def_path_str(def_id) }
1422 }
1423
1424 query lookup_deprecation_entry(def_id: DefId) -> Option<DeprecationEntry> {
1425 desc { |tcx| "checking whether `{}` is deprecated", tcx.def_path_str(def_id) }
1426 cache_on_disk_if { def_id.is_local() }
1427 separate_provide_extern
1428 }
1429
1430 query is_doc_hidden(def_id: DefId) -> bool {
1432 desc { |tcx| "checking whether `{}` is `doc(hidden)`", tcx.def_path_str(def_id) }
1433 separate_provide_extern
1434 }
1435
1436 query is_doc_notable_trait(def_id: DefId) -> bool {
1438 desc { |tcx| "checking whether `{}` is `doc(notable_trait)`", tcx.def_path_str(def_id) }
1439 }
1440
1441 query attrs_for_def(def_id: DefId) -> &'tcx [hir::Attribute] {
1445 desc { |tcx| "collecting attributes of `{}`", tcx.def_path_str(def_id) }
1446 separate_provide_extern
1447 }
1448
1449 query codegen_fn_attrs(def_id: DefId) -> &'tcx CodegenFnAttrs {
1450 desc { |tcx| "computing codegen attributes of `{}`", tcx.def_path_str(def_id) }
1451 arena_cache
1452 cache_on_disk_if { def_id.is_local() }
1453 separate_provide_extern
1454 feedable
1455 }
1456
1457 query asm_target_features(def_id: DefId) -> &'tcx FxIndexSet<Symbol> {
1458 desc { |tcx| "computing target features for inline asm of `{}`", tcx.def_path_str(def_id) }
1459 }
1460
1461 query fn_arg_idents(def_id: DefId) -> &'tcx [Option<rustc_span::Ident>] {
1462 desc { |tcx| "looking up function parameter identifiers for `{}`", tcx.def_path_str(def_id) }
1463 separate_provide_extern
1464 }
1465
1466 query rendered_const(def_id: DefId) -> &'tcx String {
1469 arena_cache
1470 desc { |tcx| "rendering constant initializer of `{}`", tcx.def_path_str(def_id) }
1471 separate_provide_extern
1472 }
1473
1474 query rendered_precise_capturing_args(def_id: DefId) -> Option<&'tcx [PreciseCapturingArgKind<Symbol, Symbol>]> {
1476 desc { |tcx| "rendering precise capturing args for `{}`", tcx.def_path_str(def_id) }
1477 separate_provide_extern
1478 }
1479
1480 query impl_parent(def_id: DefId) -> Option<DefId> {
1481 desc { |tcx| "computing specialization parent impl of `{}`", tcx.def_path_str(def_id) }
1482 separate_provide_extern
1483 }
1484
1485 query is_ctfe_mir_available(key: DefId) -> bool {
1486 desc { |tcx| "checking if item has CTFE MIR available: `{}`", tcx.def_path_str(key) }
1487 cache_on_disk_if { key.is_local() }
1488 separate_provide_extern
1489 }
1490 query is_mir_available(key: DefId) -> bool {
1491 desc { |tcx| "checking if item has MIR available: `{}`", tcx.def_path_str(key) }
1492 cache_on_disk_if { key.is_local() }
1493 separate_provide_extern
1494 }
1495
1496 query own_existential_vtable_entries(
1497 key: DefId
1498 ) -> &'tcx [DefId] {
1499 desc { |tcx| "finding all existential vtable entries for trait `{}`", tcx.def_path_str(key) }
1500 }
1501
1502 query vtable_entries(key: ty::TraitRef<'tcx>)
1503 -> &'tcx [ty::VtblEntry<'tcx>] {
1504 desc { |tcx| "finding all vtable entries for trait `{}`", tcx.def_path_str(key.def_id) }
1505 }
1506
1507 query first_method_vtable_slot(key: ty::TraitRef<'tcx>) -> usize {
1508 desc { |tcx| "finding the slot within the vtable of `{}` for the implementation of `{}`", key.self_ty(), key.print_only_trait_name() }
1509 }
1510
1511 query supertrait_vtable_slot(key: (Ty<'tcx>, Ty<'tcx>)) -> Option<usize> {
1512 desc { |tcx| "finding the slot within vtable for trait object `{}` vtable ptr during trait upcasting coercion from `{}` vtable",
1513 key.1, key.0 }
1514 }
1515
1516 query vtable_allocation(key: (Ty<'tcx>, Option<ty::ExistentialTraitRef<'tcx>>)) -> mir::interpret::AllocId {
1517 desc { |tcx| "vtable const allocation for <{} as {}>",
1518 key.0,
1519 key.1.map(|trait_ref| format!("{trait_ref}")).unwrap_or("_".to_owned())
1520 }
1521 }
1522
1523 query codegen_select_candidate(
1524 key: PseudoCanonicalInput<'tcx, ty::TraitRef<'tcx>>
1525 ) -> Result<&'tcx ImplSource<'tcx, ()>, CodegenObligationError> {
1526 cache_on_disk_if { true }
1527 desc { |tcx| "computing candidate for `{}`", key.value }
1528 }
1529
1530 query all_local_trait_impls(_: ()) -> &'tcx rustc_data_structures::fx::FxIndexMap<DefId, Vec<LocalDefId>> {
1532 desc { "finding local trait impls" }
1533 }
1534
1535 query local_trait_impls(trait_id: DefId) -> &'tcx [LocalDefId] {
1537 desc { "finding local trait impls of `{}`", tcx.def_path_str(trait_id) }
1538 }
1539
1540 query trait_impls_of(trait_id: DefId) -> &'tcx ty::trait_def::TraitImpls {
1542 arena_cache
1543 desc { |tcx| "finding trait impls of `{}`", tcx.def_path_str(trait_id) }
1544 }
1545
1546 query specialization_graph_of(trait_id: DefId) -> Result<&'tcx specialization_graph::Graph, ErrorGuaranteed> {
1547 desc { |tcx| "building specialization graph of trait `{}`", tcx.def_path_str(trait_id) }
1548 cache_on_disk_if { true }
1549 return_result_from_ensure_ok
1550 }
1551 query dyn_compatibility_violations(trait_id: DefId) -> &'tcx [DynCompatibilityViolation] {
1552 desc { |tcx| "determining dyn-compatibility of trait `{}`", tcx.def_path_str(trait_id) }
1553 }
1554 query is_dyn_compatible(trait_id: DefId) -> bool {
1555 desc { |tcx| "checking if trait `{}` is dyn-compatible", tcx.def_path_str(trait_id) }
1556 }
1557
1558 query param_env(def_id: DefId) -> ty::ParamEnv<'tcx> {
1567 desc { |tcx| "computing normalized predicates of `{}`", tcx.def_path_str(def_id) }
1568 feedable
1569 }
1570
1571 query param_env_normalized_for_post_analysis(def_id: DefId) -> ty::ParamEnv<'tcx> {
1575 desc { |tcx| "computing revealed normalized predicates of `{}`", tcx.def_path_str(def_id) }
1576 }
1577
1578 query is_copy_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1581 desc { "computing whether `{}` is `Copy`", env.value }
1582 }
1583 query is_use_cloned_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1586 desc { "computing whether `{}` is `UseCloned`", env.value }
1587 }
1588 query is_sized_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1590 desc { "computing whether `{}` is `Sized`", env.value }
1591 }
1592 query is_freeze_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1594 desc { "computing whether `{}` is freeze", env.value }
1595 }
1596 query is_unpin_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1598 desc { "computing whether `{}` is `Unpin`", env.value }
1599 }
1600 query is_async_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1602 desc { "computing whether `{}` is `AsyncDrop`", env.value }
1603 }
1604 query needs_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1606 desc { "computing whether `{}` needs drop", env.value }
1607 }
1608 query needs_async_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1610 desc { "computing whether `{}` needs async drop", env.value }
1611 }
1612 query has_significant_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1614 desc { "computing whether `{}` has a significant drop", env.value }
1615 }
1616
1617 query has_structural_eq_impl(ty: Ty<'tcx>) -> bool {
1622 desc {
1623 "computing whether `{}` implements `StructuralPartialEq`",
1624 ty
1625 }
1626 }
1627
1628 query adt_drop_tys(def_id: DefId) -> Result<&'tcx ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
1632 desc { |tcx| "computing when `{}` needs drop", tcx.def_path_str(def_id) }
1633 cache_on_disk_if { true }
1634 }
1635
1636 query adt_async_drop_tys(def_id: DefId) -> Result<&'tcx ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
1640 desc { |tcx| "computing when `{}` needs async drop", tcx.def_path_str(def_id) }
1641 cache_on_disk_if { true }
1642 }
1643
1644 query adt_significant_drop_tys(def_id: DefId) -> Result<&'tcx ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
1651 desc { |tcx| "computing when `{}` has a significant destructor", tcx.def_path_str(def_id) }
1652 }
1653
1654 query list_significant_drop_tys(ty: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> &'tcx ty::List<Ty<'tcx>> {
1672 desc { |tcx| "computing when `{}` has a significant destructor", ty.value }
1673 }
1674
1675 query layout_of(
1678 key: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>
1679 ) -> Result<ty::layout::TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
1680 depth_limit
1681 desc { "computing layout of `{}`", key.value }
1682 cycle_delay_bug
1684 }
1685
1686 query fn_abi_of_fn_ptr(
1691 key: ty::PseudoCanonicalInput<'tcx, (ty::PolyFnSig<'tcx>, &'tcx ty::List<Ty<'tcx>>)>
1692 ) -> Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, &'tcx ty::layout::FnAbiError<'tcx>> {
1693 desc { "computing call ABI of `{}` function pointers", key.value.0 }
1694 }
1695
1696 query fn_abi_of_instance(
1702 key: ty::PseudoCanonicalInput<'tcx, (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>)>
1703 ) -> Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, &'tcx ty::layout::FnAbiError<'tcx>> {
1704 desc { "computing call ABI of `{}`", key.value.0 }
1705 }
1706
1707 query dylib_dependency_formats(_: CrateNum)
1708 -> &'tcx [(CrateNum, LinkagePreference)] {
1709 desc { "getting dylib dependency formats of crate" }
1710 separate_provide_extern
1711 }
1712
1713 query dependency_formats(_: ()) -> &'tcx Arc<crate::middle::dependency_format::Dependencies> {
1714 arena_cache
1715 desc { "getting the linkage format of all dependencies" }
1716 }
1717
1718 query is_compiler_builtins(_: CrateNum) -> bool {
1719 fatal_cycle
1720 desc { "checking if the crate is_compiler_builtins" }
1721 separate_provide_extern
1722 }
1723 query has_global_allocator(_: CrateNum) -> bool {
1724 eval_always
1726 fatal_cycle
1727 desc { "checking if the crate has_global_allocator" }
1728 separate_provide_extern
1729 }
1730 query has_alloc_error_handler(_: CrateNum) -> bool {
1731 eval_always
1733 fatal_cycle
1734 desc { "checking if the crate has_alloc_error_handler" }
1735 separate_provide_extern
1736 }
1737 query has_panic_handler(_: CrateNum) -> bool {
1738 fatal_cycle
1739 desc { "checking if the crate has_panic_handler" }
1740 separate_provide_extern
1741 }
1742 query is_profiler_runtime(_: CrateNum) -> bool {
1743 fatal_cycle
1744 desc { "checking if a crate is `#![profiler_runtime]`" }
1745 separate_provide_extern
1746 }
1747 query has_ffi_unwind_calls(key: LocalDefId) -> bool {
1748 desc { |tcx| "checking if `{}` contains FFI-unwind calls", tcx.def_path_str(key) }
1749 cache_on_disk_if { true }
1750 }
1751 query required_panic_strategy(_: CrateNum) -> Option<PanicStrategy> {
1752 fatal_cycle
1753 desc { "getting a crate's required panic strategy" }
1754 separate_provide_extern
1755 }
1756 query panic_in_drop_strategy(_: CrateNum) -> PanicStrategy {
1757 fatal_cycle
1758 desc { "getting a crate's configured panic-in-drop strategy" }
1759 separate_provide_extern
1760 }
1761 query is_no_builtins(_: CrateNum) -> bool {
1762 fatal_cycle
1763 desc { "getting whether a crate has `#![no_builtins]`" }
1764 separate_provide_extern
1765 }
1766 query symbol_mangling_version(_: CrateNum) -> SymbolManglingVersion {
1767 fatal_cycle
1768 desc { "getting a crate's symbol mangling version" }
1769 separate_provide_extern
1770 }
1771
1772 query extern_crate(def_id: CrateNum) -> Option<&'tcx ExternCrate> {
1773 eval_always
1774 desc { "getting crate's ExternCrateData" }
1775 separate_provide_extern
1776 }
1777
1778 query specialization_enabled_in(cnum: CrateNum) -> bool {
1779 desc { "checking whether the crate enabled `specialization`/`min_specialization`" }
1780 separate_provide_extern
1781 }
1782
1783 query specializes(_: (DefId, DefId)) -> bool {
1784 desc { "computing whether impls specialize one another" }
1785 }
1786 query in_scope_traits_map(_: hir::OwnerId)
1787 -> Option<&'tcx ItemLocalMap<Box<[TraitCandidate]>>> {
1788 desc { "getting traits in scope at a block" }
1789 }
1790
1791 query defaultness(def_id: DefId) -> hir::Defaultness {
1793 desc { |tcx| "looking up whether `{}` has `default`", tcx.def_path_str(def_id) }
1794 separate_provide_extern
1795 feedable
1796 }
1797
1798 query check_well_formed(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
1799 desc { |tcx| "checking that `{}` is well-formed", tcx.def_path_str(key) }
1800 return_result_from_ensure_ok
1801 }
1802
1803 query enforce_impl_non_lifetime_params_are_constrained(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
1804 desc { |tcx| "checking that `{}`'s generics are constrained by the impl header", tcx.def_path_str(key) }
1805 return_result_from_ensure_ok
1806 }
1807
1808 query reachable_non_generics(_: CrateNum)
1821 -> &'tcx DefIdMap<SymbolExportInfo> {
1822 arena_cache
1823 desc { "looking up the exported symbols of a crate" }
1824 separate_provide_extern
1825 }
1826 query is_reachable_non_generic(def_id: DefId) -> bool {
1827 desc { |tcx| "checking whether `{}` is an exported symbol", tcx.def_path_str(def_id) }
1828 cache_on_disk_if { def_id.is_local() }
1829 separate_provide_extern
1830 }
1831 query is_unreachable_local_definition(def_id: LocalDefId) -> bool {
1832 desc { |tcx|
1833 "checking whether `{}` is reachable from outside the crate",
1834 tcx.def_path_str(def_id),
1835 }
1836 }
1837
1838 query upstream_monomorphizations(_: ()) -> &'tcx DefIdMap<UnordMap<GenericArgsRef<'tcx>, CrateNum>> {
1846 arena_cache
1847 desc { "collecting available upstream monomorphizations" }
1848 }
1849
1850 query upstream_monomorphizations_for(def_id: DefId)
1858 -> Option<&'tcx UnordMap<GenericArgsRef<'tcx>, CrateNum>>
1859 {
1860 desc { |tcx|
1861 "collecting available upstream monomorphizations for `{}`",
1862 tcx.def_path_str(def_id),
1863 }
1864 separate_provide_extern
1865 }
1866
1867 query upstream_drop_glue_for(args: GenericArgsRef<'tcx>) -> Option<CrateNum> {
1883 desc { "available upstream drop-glue for `{:?}`", args }
1884 }
1885
1886 query upstream_async_drop_glue_for(args: GenericArgsRef<'tcx>) -> Option<CrateNum> {
1903 desc { "available upstream async-drop-glue for `{:?}`", args }
1904 }
1905
1906 query foreign_modules(_: CrateNum) -> &'tcx FxIndexMap<DefId, ForeignModule> {
1908 arena_cache
1909 desc { "looking up the foreign modules of a linked crate" }
1910 separate_provide_extern
1911 }
1912
1913 query clashing_extern_declarations(_: ()) {
1915 desc { "checking `extern fn` declarations are compatible" }
1916 }
1917
1918 query entry_fn(_: ()) -> Option<(DefId, EntryFnType)> {
1921 desc { "looking up the entry function of a crate" }
1922 }
1923
1924 query proc_macro_decls_static(_: ()) -> Option<LocalDefId> {
1926 desc { "looking up the proc macro declarations for a crate" }
1927 }
1928
1929 query crate_hash(_: CrateNum) -> Svh {
1937 eval_always
1938 desc { "looking up the hash a crate" }
1939 separate_provide_extern
1940 }
1941
1942 query crate_host_hash(_: CrateNum) -> Option<Svh> {
1944 eval_always
1945 desc { "looking up the hash of a host version of a crate" }
1946 separate_provide_extern
1947 }
1948
1949 query extra_filename(_: CrateNum) -> &'tcx String {
1952 arena_cache
1953 eval_always
1954 desc { "looking up the extra filename for a crate" }
1955 separate_provide_extern
1956 }
1957
1958 query crate_extern_paths(_: CrateNum) -> &'tcx Vec<PathBuf> {
1960 arena_cache
1961 eval_always
1962 desc { "looking up the paths for extern crates" }
1963 separate_provide_extern
1964 }
1965
1966 query implementations_of_trait(_: (CrateNum, DefId)) -> &'tcx [(DefId, Option<SimplifiedType>)] {
1969 desc { "looking up implementations of a trait in a crate" }
1970 separate_provide_extern
1971 }
1972
1973 query crate_incoherent_impls(key: (CrateNum, SimplifiedType)) -> &'tcx [DefId] {
1978 desc { |tcx| "collecting all impls for a type in a crate" }
1979 separate_provide_extern
1980 }
1981
1982 query native_library(def_id: DefId) -> Option<&'tcx NativeLib> {
1984 desc { |tcx| "getting the native library for `{}`", tcx.def_path_str(def_id) }
1985 }
1986
1987 query inherit_sig_for_delegation_item(def_id: LocalDefId) -> &'tcx [Ty<'tcx>] {
1988 desc { "inheriting delegation signature" }
1989 }
1990
1991 query resolve_bound_vars(owner_id: hir::OwnerId) -> &'tcx ResolveBoundVars {
1995 arena_cache
1996 desc { |tcx| "resolving lifetimes for `{}`", tcx.def_path_str(owner_id) }
1997 }
1998 query named_variable_map(owner_id: hir::OwnerId) -> &'tcx SortedMap<ItemLocalId, ResolvedArg> {
1999 desc { |tcx| "looking up a named region inside `{}`", tcx.def_path_str(owner_id) }
2000 }
2001 query is_late_bound_map(owner_id: hir::OwnerId) -> Option<&'tcx FxIndexSet<ItemLocalId>> {
2002 desc { |tcx| "testing if a region is late bound inside `{}`", tcx.def_path_str(owner_id) }
2003 }
2004 query object_lifetime_default(def_id: DefId) -> ObjectLifetimeDefault {
2019 desc { "looking up lifetime defaults for type parameter `{}`", tcx.def_path_str(def_id) }
2020 separate_provide_extern
2021 }
2022 query late_bound_vars_map(owner_id: hir::OwnerId)
2023 -> &'tcx SortedMap<ItemLocalId, Vec<ty::BoundVariableKind>> {
2024 desc { |tcx| "looking up late bound vars inside `{}`", tcx.def_path_str(owner_id) }
2025 }
2026 query opaque_captured_lifetimes(def_id: LocalDefId) -> &'tcx [(ResolvedArg, LocalDefId)] {
2041 desc { |tcx| "listing captured lifetimes for opaque `{}`", tcx.def_path_str(def_id) }
2042 }
2043
2044 query visibility(def_id: DefId) -> ty::Visibility<DefId> {
2057 desc { |tcx| "computing visibility of `{}`", tcx.def_path_str(def_id) }
2058 separate_provide_extern
2059 feedable
2060 }
2061
2062 query inhabited_predicate_adt(key: DefId) -> ty::inhabitedness::InhabitedPredicate<'tcx> {
2063 desc { "computing the uninhabited predicate of `{:?}`", key }
2064 }
2065
2066 query inhabited_predicate_type(key: Ty<'tcx>) -> ty::inhabitedness::InhabitedPredicate<'tcx> {
2068 desc { "computing the uninhabited predicate of `{}`", key }
2069 }
2070
2071 query dep_kind(_: CrateNum) -> CrateDepKind {
2072 eval_always
2073 desc { "fetching what a dependency looks like" }
2074 separate_provide_extern
2075 }
2076
2077 query crate_name(_: CrateNum) -> Symbol {
2079 feedable
2080 desc { "fetching what a crate is named" }
2081 separate_provide_extern
2082 }
2083 query module_children(def_id: DefId) -> &'tcx [ModChild] {
2084 desc { |tcx| "collecting child items of module `{}`", tcx.def_path_str(def_id) }
2085 separate_provide_extern
2086 }
2087 query extern_mod_stmt_cnum(def_id: LocalDefId) -> Option<CrateNum> {
2088 desc { |tcx| "computing crate imported by `{}`", tcx.def_path_str(def_id) }
2089 }
2090
2091 query num_extern_def_ids(_: CrateNum) -> usize {
2097 desc { "fetching the number of definitions in a crate" }
2098 separate_provide_extern
2099 }
2100
2101 query lib_features(_: CrateNum) -> &'tcx LibFeatures {
2102 desc { "calculating the lib features defined in a crate" }
2103 separate_provide_extern
2104 arena_cache
2105 }
2106 query stability_implications(_: CrateNum) -> &'tcx UnordMap<Symbol, Symbol> {
2107 arena_cache
2108 desc { "calculating the implications between `#[unstable]` features defined in a crate" }
2109 separate_provide_extern
2110 }
2111 query intrinsic_raw(def_id: DefId) -> Option<rustc_middle::ty::IntrinsicDef> {
2113 desc { |tcx| "fetch intrinsic name if `{}` is an intrinsic", tcx.def_path_str(def_id) }
2114 separate_provide_extern
2115 }
2116 query get_lang_items(_: ()) -> &'tcx LanguageItems {
2118 arena_cache
2119 eval_always
2120 desc { "calculating the lang items map" }
2121 }
2122
2123 query all_diagnostic_items(_: ()) -> &'tcx rustc_hir::diagnostic_items::DiagnosticItems {
2125 arena_cache
2126 eval_always
2127 desc { "calculating the diagnostic items map" }
2128 }
2129
2130 query defined_lang_items(_: CrateNum) -> &'tcx [(DefId, LangItem)] {
2132 desc { "calculating the lang items defined in a crate" }
2133 separate_provide_extern
2134 }
2135
2136 query diagnostic_items(_: CrateNum) -> &'tcx rustc_hir::diagnostic_items::DiagnosticItems {
2138 arena_cache
2139 desc { "calculating the diagnostic items map in a crate" }
2140 separate_provide_extern
2141 }
2142
2143 query missing_lang_items(_: CrateNum) -> &'tcx [LangItem] {
2144 desc { "calculating the missing lang items in a crate" }
2145 separate_provide_extern
2146 }
2147
2148 query visible_parent_map(_: ()) -> &'tcx DefIdMap<DefId> {
2153 arena_cache
2154 desc { "calculating the visible parent map" }
2155 }
2156 query trimmed_def_paths(_: ()) -> &'tcx DefIdMap<Symbol> {
2159 arena_cache
2160 desc { "calculating trimmed def paths" }
2161 }
2162 query missing_extern_crate_item(_: CrateNum) -> bool {
2163 eval_always
2164 desc { "seeing if we're missing an `extern crate` item for this crate" }
2165 separate_provide_extern
2166 }
2167 query used_crate_source(_: CrateNum) -> &'tcx Arc<CrateSource> {
2168 arena_cache
2169 eval_always
2170 desc { "looking at the source for a crate" }
2171 separate_provide_extern
2172 }
2173
2174 query debugger_visualizers(_: CrateNum) -> &'tcx Vec<DebuggerVisualizerFile> {
2179 arena_cache
2180 desc { "looking up the debugger visualizers for this crate" }
2181 separate_provide_extern
2182 eval_always
2183 }
2184
2185 query postorder_cnums(_: ()) -> &'tcx [CrateNum] {
2186 eval_always
2187 desc { "generating a postorder list of CrateNums" }
2188 }
2189 query is_private_dep(c: CrateNum) -> bool {
2192 eval_always
2193 desc { "checking whether crate `{}` is a private dependency", c }
2194 separate_provide_extern
2195 }
2196 query allocator_kind(_: ()) -> Option<AllocatorKind> {
2197 eval_always
2198 desc { "getting the allocator kind for the current crate" }
2199 }
2200 query alloc_error_handler_kind(_: ()) -> Option<AllocatorKind> {
2201 eval_always
2202 desc { "alloc error handler kind for the current crate" }
2203 }
2204
2205 query upvars_mentioned(def_id: DefId) -> Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>> {
2206 desc { |tcx| "collecting upvars mentioned in `{}`", tcx.def_path_str(def_id) }
2207 }
2208 query maybe_unused_trait_imports(_: ()) -> &'tcx FxIndexSet<LocalDefId> {
2209 desc { "fetching potentially unused trait imports" }
2210 }
2211 query names_imported_by_glob_use(def_id: LocalDefId) -> &'tcx FxIndexSet<Symbol> {
2212 desc { |tcx| "finding names imported by glob use for `{}`", tcx.def_path_str(def_id) }
2213 }
2214
2215 query stability_index(_: ()) -> &'tcx stability::Index {
2216 arena_cache
2217 eval_always
2218 desc { "calculating the stability index for the local crate" }
2219 }
2220 query crates(_: ()) -> &'tcx [CrateNum] {
2223 eval_always
2224 desc { "fetching all foreign CrateNum instances" }
2225 }
2226 query used_crates(_: ()) -> &'tcx [CrateNum] {
2230 eval_always
2231 desc { "fetching `CrateNum`s for all crates loaded non-speculatively" }
2232 }
2233
2234 query traits(_: CrateNum) -> &'tcx [DefId] {
2236 desc { "fetching all traits in a crate" }
2237 separate_provide_extern
2238 }
2239
2240 query trait_impls_in_crate(_: CrateNum) -> &'tcx [DefId] {
2241 desc { "fetching all trait impls in a crate" }
2242 separate_provide_extern
2243 }
2244
2245 query stable_order_of_exportable_impls(_: CrateNum) -> &'tcx FxIndexMap<DefId, usize> {
2246 desc { "fetching the stable impl's order" }
2247 separate_provide_extern
2248 }
2249
2250 query exportable_items(_: CrateNum) -> &'tcx [DefId] {
2251 desc { "fetching all exportable items in a crate" }
2252 separate_provide_extern
2253 }
2254
2255 query exported_symbols(cnum: CrateNum) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)] {
2261 desc { "collecting exported symbols for crate `{}`", cnum}
2262 cache_on_disk_if { *cnum == LOCAL_CRATE }
2263 separate_provide_extern
2264 }
2265
2266 query collect_and_partition_mono_items(_: ()) -> MonoItemPartitions<'tcx> {
2267 eval_always
2268 desc { "collect_and_partition_mono_items" }
2269 }
2270
2271 query is_codegened_item(def_id: DefId) -> bool {
2272 desc { |tcx| "determining whether `{}` needs codegen", tcx.def_path_str(def_id) }
2273 }
2274
2275 query codegen_unit(sym: Symbol) -> &'tcx CodegenUnit<'tcx> {
2276 desc { "getting codegen unit `{sym}`" }
2277 }
2278
2279 query backend_optimization_level(_: ()) -> OptLevel {
2280 desc { "optimization level used by backend" }
2281 }
2282
2283 query output_filenames(_: ()) -> &'tcx Arc<OutputFilenames> {
2288 feedable
2289 desc { "getting output filenames" }
2290 arena_cache
2291 }
2292
2293 query normalize_canonicalized_projection_ty(
2299 goal: CanonicalAliasGoal<'tcx>
2300 ) -> Result<
2301 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, NormalizationResult<'tcx>>>,
2302 NoSolution,
2303 > {
2304 desc { "normalizing `{}`", goal.canonical.value.value }
2305 }
2306
2307 query normalize_canonicalized_free_alias(
2313 goal: CanonicalAliasGoal<'tcx>
2314 ) -> Result<
2315 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, NormalizationResult<'tcx>>>,
2316 NoSolution,
2317 > {
2318 desc { "normalizing `{}`", goal.canonical.value.value }
2319 }
2320
2321 query normalize_canonicalized_inherent_projection_ty(
2327 goal: CanonicalAliasGoal<'tcx>
2328 ) -> Result<
2329 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, NormalizationResult<'tcx>>>,
2330 NoSolution,
2331 > {
2332 desc { "normalizing `{}`", goal.canonical.value.value }
2333 }
2334
2335 query try_normalize_generic_arg_after_erasing_regions(
2337 goal: PseudoCanonicalInput<'tcx, GenericArg<'tcx>>
2338 ) -> Result<GenericArg<'tcx>, NoSolution> {
2339 desc { "normalizing `{}`", goal.value }
2340 }
2341
2342 query implied_outlives_bounds(
2343 key: (CanonicalImpliedOutlivesBoundsGoal<'tcx>, bool)
2344 ) -> Result<
2345 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>,
2346 NoSolution,
2347 > {
2348 desc { "computing implied outlives bounds for `{}` (hack disabled = {:?})", key.0.canonical.value.value.ty, key.1 }
2349 }
2350
2351 query dropck_outlives(
2354 goal: CanonicalDropckOutlivesGoal<'tcx>
2355 ) -> Result<
2356 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>,
2357 NoSolution,
2358 > {
2359 desc { "computing dropck types for `{}`", goal.canonical.value.value.dropped_ty }
2360 }
2361
2362 query evaluate_obligation(
2365 goal: CanonicalPredicateGoal<'tcx>
2366 ) -> Result<EvaluationResult, OverflowError> {
2367 desc { "evaluating trait selection obligation `{}`", goal.canonical.value.value }
2368 }
2369
2370 query type_op_ascribe_user_type(
2372 goal: CanonicalTypeOpAscribeUserTypeGoal<'tcx>
2373 ) -> Result<
2374 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ()>>,
2375 NoSolution,
2376 > {
2377 desc { "evaluating `type_op_ascribe_user_type` `{:?}`", goal.canonical.value.value }
2378 }
2379
2380 query type_op_prove_predicate(
2382 goal: CanonicalTypeOpProvePredicateGoal<'tcx>
2383 ) -> Result<
2384 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ()>>,
2385 NoSolution,
2386 > {
2387 desc { "evaluating `type_op_prove_predicate` `{:?}`", goal.canonical.value.value }
2388 }
2389
2390 query type_op_normalize_ty(
2392 goal: CanonicalTypeOpNormalizeGoal<'tcx, Ty<'tcx>>
2393 ) -> Result<
2394 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Ty<'tcx>>>,
2395 NoSolution,
2396 > {
2397 desc { "normalizing `{}`", goal.canonical.value.value.value }
2398 }
2399
2400 query type_op_normalize_clause(
2402 goal: CanonicalTypeOpNormalizeGoal<'tcx, ty::Clause<'tcx>>
2403 ) -> Result<
2404 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ty::Clause<'tcx>>>,
2405 NoSolution,
2406 > {
2407 desc { "normalizing `{:?}`", goal.canonical.value.value.value }
2408 }
2409
2410 query type_op_normalize_poly_fn_sig(
2412 goal: CanonicalTypeOpNormalizeGoal<'tcx, ty::PolyFnSig<'tcx>>
2413 ) -> Result<
2414 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ty::PolyFnSig<'tcx>>>,
2415 NoSolution,
2416 > {
2417 desc { "normalizing `{:?}`", goal.canonical.value.value.value }
2418 }
2419
2420 query type_op_normalize_fn_sig(
2422 goal: CanonicalTypeOpNormalizeGoal<'tcx, ty::FnSig<'tcx>>
2423 ) -> Result<
2424 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ty::FnSig<'tcx>>>,
2425 NoSolution,
2426 > {
2427 desc { "normalizing `{:?}`", goal.canonical.value.value.value }
2428 }
2429
2430 query instantiate_and_check_impossible_predicates(key: (DefId, GenericArgsRef<'tcx>)) -> bool {
2431 desc { |tcx|
2432 "checking impossible instantiated predicates: `{}`",
2433 tcx.def_path_str(key.0)
2434 }
2435 }
2436
2437 query is_impossible_associated_item(key: (DefId, DefId)) -> bool {
2438 desc { |tcx|
2439 "checking if `{}` is impossible to reference within `{}`",
2440 tcx.def_path_str(key.1),
2441 tcx.def_path_str(key.0),
2442 }
2443 }
2444
2445 query method_autoderef_steps(
2446 goal: CanonicalTyGoal<'tcx>
2447 ) -> MethodAutoderefStepsResult<'tcx> {
2448 desc { "computing autoderef types for `{}`", goal.canonical.value.value }
2449 }
2450
2451 query rust_target_features(_: CrateNum) -> &'tcx UnordMap<String, rustc_target::target_features::Stability> {
2453 arena_cache
2454 eval_always
2455 desc { "looking up Rust target features" }
2456 }
2457
2458 query implied_target_features(feature: Symbol) -> &'tcx Vec<Symbol> {
2459 arena_cache
2460 eval_always
2461 desc { "looking up implied target features" }
2462 }
2463
2464 query features_query(_: ()) -> &'tcx rustc_feature::Features {
2465 feedable
2466 desc { "looking up enabled feature gates" }
2467 }
2468
2469 query crate_for_resolver((): ()) -> &'tcx Steal<(rustc_ast::Crate, rustc_ast::AttrVec)> {
2470 feedable
2471 no_hash
2472 desc { "the ast before macro expansion and name resolution" }
2473 }
2474
2475 query resolve_instance_raw(
2485 key: ty::PseudoCanonicalInput<'tcx, (DefId, GenericArgsRef<'tcx>)>
2486 ) -> Result<Option<ty::Instance<'tcx>>, ErrorGuaranteed> {
2487 desc { "resolving instance `{}`", ty::Instance::new_raw(key.value.0, key.value.1) }
2488 }
2489
2490 query reveal_opaque_types_in_bounds(key: ty::Clauses<'tcx>) -> ty::Clauses<'tcx> {
2491 desc { "revealing opaque types in `{:?}`", key }
2492 }
2493
2494 query limits(key: ()) -> Limits {
2495 desc { "looking up limits" }
2496 }
2497
2498 query diagnostic_hir_wf_check(
2507 key: (ty::Predicate<'tcx>, WellFormedLoc)
2508 ) -> Option<&'tcx ObligationCause<'tcx>> {
2509 arena_cache
2510 eval_always
2511 no_hash
2512 desc { "performing HIR wf-checking for predicate `{:?}` at item `{:?}`", key.0, key.1 }
2513 }
2514
2515 query global_backend_features(_: ()) -> &'tcx Vec<String> {
2518 arena_cache
2519 eval_always
2520 desc { "computing the backend features for CLI flags" }
2521 }
2522
2523 query check_validity_requirement(key: (ValidityRequirement, ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>)) -> Result<bool, &'tcx ty::layout::LayoutError<'tcx>> {
2524 desc { "checking validity requirement for `{}`: {}", key.1.value, key.0 }
2525 }
2526
2527 query compare_impl_item(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
2532 desc { |tcx| "checking assoc item `{}` is compatible with trait definition", tcx.def_path_str(key) }
2533 return_result_from_ensure_ok
2534 }
2535
2536 query deduced_param_attrs(def_id: DefId) -> &'tcx [ty::DeducedParamAttrs] {
2537 desc { |tcx| "deducing parameter attributes for {}", tcx.def_path_str(def_id) }
2538 separate_provide_extern
2539 }
2540
2541 query doc_link_resolutions(def_id: DefId) -> &'tcx DocLinkResMap {
2542 eval_always
2543 desc { "resolutions for documentation links for a module" }
2544 separate_provide_extern
2545 }
2546
2547 query doc_link_traits_in_scope(def_id: DefId) -> &'tcx [DefId] {
2548 eval_always
2549 desc { "traits in scope for documentation links for a module" }
2550 separate_provide_extern
2551 }
2552
2553 query stripped_cfg_items(cnum: CrateNum) -> &'tcx [StrippedCfgItem] {
2557 desc { "getting cfg-ed out item names" }
2558 separate_provide_extern
2559 }
2560
2561 query generics_require_sized_self(def_id: DefId) -> bool {
2562 desc { "check whether the item has a `where Self: Sized` bound" }
2563 }
2564
2565 query cross_crate_inlinable(def_id: DefId) -> bool {
2566 desc { "whether the item should be made inlinable across crates" }
2567 separate_provide_extern
2568 }
2569
2570 query check_mono_item(key: ty::Instance<'tcx>) {
2574 desc { "monomorphization-time checking" }
2575 }
2576
2577 query skip_move_check_fns(_: ()) -> &'tcx FxIndexSet<DefId> {
2579 arena_cache
2580 desc { "functions to skip for move-size check" }
2581 }
2582
2583 query items_of_instance(key: (ty::Instance<'tcx>, CollectionMode)) -> (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]) {
2584 desc { "collecting items used by `{}`", key.0 }
2585 cache_on_disk_if { true }
2586 }
2587
2588 query size_estimate(key: ty::Instance<'tcx>) -> usize {
2589 desc { "estimating codegen size of `{}`", key }
2590 cache_on_disk_if { true }
2591 }
2592
2593 query anon_const_kind(def_id: DefId) -> ty::AnonConstKind {
2594 desc { |tcx| "looking up anon const kind of `{}`", tcx.def_path_str(def_id) }
2595 separate_provide_extern
2596 }
2597}
2598
2599rustc_with_all_queries! { define_callbacks! }
2600rustc_feedable_queries! { define_feedable! }