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> {
540 no_hash
542 desc { |tcx| "building THIR for `{}`", tcx.def_path_str(key) }
543 }
544
545 query mir_keys(_: ()) -> &'tcx rustc_data_structures::fx::FxIndexSet<LocalDefId> {
549 arena_cache
550 desc { "getting a list of all mir_keys" }
551 }
552
553 query mir_const_qualif(key: DefId) -> mir::ConstQualifs {
557 desc { |tcx| "const checking `{}`", tcx.def_path_str(key) }
558 cache_on_disk_if { key.is_local() }
559 separate_provide_extern
560 }
561
562 query mir_built(key: LocalDefId) -> &'tcx Steal<mir::Body<'tcx>> {
568 desc { |tcx| "building MIR for `{}`", tcx.def_path_str(key) }
569 feedable
570 }
571
572 query thir_abstract_const(
574 key: DefId
575 ) -> Result<Option<ty::EarlyBinder<'tcx, ty::Const<'tcx>>>, ErrorGuaranteed> {
576 desc {
577 |tcx| "building an abstract representation for `{}`", tcx.def_path_str(key),
578 }
579 separate_provide_extern
580 }
581
582 query mir_drops_elaborated_and_const_checked(key: LocalDefId) -> &'tcx Steal<mir::Body<'tcx>> {
583 no_hash
584 desc { |tcx| "elaborating drops for `{}`", tcx.def_path_str(key) }
585 }
586
587 query mir_for_ctfe(
588 key: DefId
589 ) -> &'tcx mir::Body<'tcx> {
590 desc { |tcx| "caching mir of `{}` for CTFE", tcx.def_path_str(key) }
591 cache_on_disk_if { key.is_local() }
592 separate_provide_extern
593 }
594
595 query mir_promoted(key: LocalDefId) -> (
596 &'tcx Steal<mir::Body<'tcx>>,
597 &'tcx Steal<IndexVec<mir::Promoted, mir::Body<'tcx>>>
598 ) {
599 no_hash
600 desc { |tcx| "promoting constants in MIR for `{}`", tcx.def_path_str(key) }
601 }
602
603 query closure_typeinfo(key: LocalDefId) -> ty::ClosureTypeInfo<'tcx> {
604 desc {
605 |tcx| "finding symbols for captures of closure `{}`",
606 tcx.def_path_str(key)
607 }
608 }
609
610 query closure_saved_names_of_captured_variables(def_id: DefId) -> &'tcx IndexVec<abi::FieldIdx, Symbol> {
618 arena_cache
619 desc { |tcx| "computing debuginfo for closure `{}`", tcx.def_path_str(def_id) }
620 separate_provide_extern
621 }
622
623 query mir_coroutine_witnesses(key: DefId) -> Option<&'tcx mir::CoroutineLayout<'tcx>> {
624 arena_cache
625 desc { |tcx| "coroutine witness types for `{}`", tcx.def_path_str(key) }
626 cache_on_disk_if { key.is_local() }
627 separate_provide_extern
628 }
629
630 query check_coroutine_obligations(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
631 desc { |tcx| "verify auto trait bounds for coroutine interior type `{}`", tcx.def_path_str(key) }
632 return_result_from_ensure_ok
633 }
634
635 query optimized_mir(key: DefId) -> &'tcx mir::Body<'tcx> {
638 desc { |tcx| "optimizing MIR for `{}`", tcx.def_path_str(key) }
639 cache_on_disk_if { key.is_local() }
640 separate_provide_extern
641 }
642
643 query coverage_attr_on(key: LocalDefId) -> bool {
649 desc { |tcx| "checking for `#[coverage(..)]` on `{}`", tcx.def_path_str(key) }
650 feedable
651 }
652
653 query coverage_ids_info(key: ty::InstanceKind<'tcx>) -> Option<&'tcx mir::coverage::CoverageIdsInfo> {
666 desc { |tcx| "retrieving coverage IDs info from MIR for `{}`", tcx.def_path_str(key.def_id()) }
667 arena_cache
668 }
669
670 query promoted_mir(key: DefId) -> &'tcx IndexVec<mir::Promoted, mir::Body<'tcx>> {
676 desc { |tcx| "optimizing promoted MIR for `{}`", tcx.def_path_str(key) }
677 cache_on_disk_if { key.is_local() }
678 separate_provide_extern
679 }
680
681 query erase_regions_ty(ty: Ty<'tcx>) -> Ty<'tcx> {
685 anon
692 desc { "erasing regions from `{}`", ty }
693 }
694
695 query wasm_import_module_map(_: CrateNum) -> &'tcx DefIdMap<String> {
696 arena_cache
697 desc { "getting wasm import module map" }
698 }
699
700 query trait_explicit_predicates_and_bounds(key: LocalDefId) -> ty::GenericPredicates<'tcx> {
722 desc { |tcx| "computing explicit predicates of trait `{}`", tcx.def_path_str(key) }
723 }
724
725 query explicit_predicates_of(key: DefId) -> ty::GenericPredicates<'tcx> {
731 desc { |tcx| "computing explicit predicates of `{}`", tcx.def_path_str(key) }
732 cache_on_disk_if { key.is_local() }
733 separate_provide_extern
734 feedable
735 }
736
737 query inferred_outlives_of(key: DefId) -> &'tcx [(ty::Clause<'tcx>, Span)] {
744 desc { |tcx| "computing inferred outlives-predicates of `{}`", tcx.def_path_str(key) }
745 cache_on_disk_if { key.is_local() }
746 separate_provide_extern
747 feedable
748 }
749
750 query explicit_super_predicates_of(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
758 desc { |tcx| "computing the super predicates of `{}`", tcx.def_path_str(key) }
759 cache_on_disk_if { key.is_local() }
760 separate_provide_extern
761 }
762
763 query explicit_implied_predicates_of(key: DefId) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
770 desc { |tcx| "computing the implied predicates of `{}`", tcx.def_path_str(key) }
771 cache_on_disk_if { key.is_local() }
772 separate_provide_extern
773 }
774
775 query explicit_supertraits_containing_assoc_item(
779 key: (DefId, rustc_span::Ident)
780 ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
781 desc { |tcx| "computing the super traits of `{}` with associated type name `{}`",
782 tcx.def_path_str(key.0),
783 key.1
784 }
785 }
786
787 query const_conditions(
797 key: DefId
798 ) -> ty::ConstConditions<'tcx> {
799 desc { |tcx| "computing the conditions for `{}` to be considered const",
800 tcx.def_path_str(key)
801 }
802 separate_provide_extern
803 }
804
805 query explicit_implied_const_bounds(
811 key: DefId
812 ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::PolyTraitRef<'tcx>, Span)]> {
813 desc { |tcx| "computing the implied `~const` bounds for `{}`",
814 tcx.def_path_str(key)
815 }
816 separate_provide_extern
817 }
818
819 query type_param_predicates(
822 key: (LocalDefId, LocalDefId, rustc_span::Ident)
823 ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> {
824 desc { |tcx| "computing the bounds for type parameter `{}`", tcx.hir_ty_param_name(key.1) }
825 }
826
827 query trait_def(key: DefId) -> &'tcx ty::TraitDef {
828 desc { |tcx| "computing trait definition for `{}`", tcx.def_path_str(key) }
829 arena_cache
830 cache_on_disk_if { key.is_local() }
831 separate_provide_extern
832 }
833 query adt_def(key: DefId) -> ty::AdtDef<'tcx> {
834 desc { |tcx| "computing ADT definition for `{}`", tcx.def_path_str(key) }
835 cache_on_disk_if { key.is_local() }
836 separate_provide_extern
837 }
838 query adt_destructor(key: DefId) -> Option<ty::Destructor> {
839 desc { |tcx| "computing `Drop` impl for `{}`", tcx.def_path_str(key) }
840 cache_on_disk_if { key.is_local() }
841 separate_provide_extern
842 }
843 query adt_async_destructor(key: DefId) -> Option<ty::AsyncDestructor> {
844 desc { |tcx| "computing `AsyncDrop` impl for `{}`", tcx.def_path_str(key) }
845 cache_on_disk_if { key.is_local() }
846 separate_provide_extern
847 }
848
849 query adt_sized_constraint(key: DefId) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
850 desc { |tcx| "computing the `Sized` constraint for `{}`", tcx.def_path_str(key) }
851 }
852
853 query adt_dtorck_constraint(
854 key: DefId
855 ) -> &'tcx DropckConstraint<'tcx> {
856 desc { |tcx| "computing drop-check constraints for `{}`", tcx.def_path_str(key) }
857 }
858
859 query constness(key: DefId) -> hir::Constness {
881 desc { |tcx| "checking if item is const: `{}`", tcx.def_path_str(key) }
882 separate_provide_extern
883 feedable
884 }
885
886 query asyncness(key: DefId) -> ty::Asyncness {
887 desc { |tcx| "checking if the function is async: `{}`", tcx.def_path_str(key) }
888 separate_provide_extern
889 }
890
891 query is_promotable_const_fn(key: DefId) -> bool {
899 desc { |tcx| "checking if item is promotable: `{}`", tcx.def_path_str(key) }
900 }
901
902 query coroutine_by_move_body_def_id(def_id: DefId) -> DefId {
909 desc { |tcx| "looking up the coroutine by-move body for `{}`", tcx.def_path_str(def_id) }
910 separate_provide_extern
911 }
912
913 query coroutine_kind(def_id: DefId) -> Option<hir::CoroutineKind> {
915 desc { |tcx| "looking up coroutine kind of `{}`", tcx.def_path_str(def_id) }
916 separate_provide_extern
917 feedable
918 }
919
920 query coroutine_for_closure(def_id: DefId) -> DefId {
921 desc { |_tcx| "Given a coroutine-closure def id, return the def id of the coroutine returned by it" }
922 separate_provide_extern
923 }
924
925 query crate_variances(_: ()) -> &'tcx ty::CrateVariancesMap<'tcx> {
933 arena_cache
934 desc { "computing the variances for items in this crate" }
935 }
936
937 query variances_of(def_id: DefId) -> &'tcx [ty::Variance] {
945 desc { |tcx| "computing the variances of `{}`", tcx.def_path_str(def_id) }
946 cache_on_disk_if { def_id.is_local() }
947 separate_provide_extern
948 cycle_delay_bug
949 }
950
951 query inferred_outlives_crate(_: ()) -> &'tcx ty::CratePredicatesMap<'tcx> {
959 arena_cache
960 desc { "computing the inferred outlives-predicates for items in this crate" }
961 }
962
963 query associated_item_def_ids(key: DefId) -> &'tcx [DefId] {
966 desc { |tcx| "collecting associated items or fields of `{}`", tcx.def_path_str(key) }
967 cache_on_disk_if { key.is_local() }
968 separate_provide_extern
969 }
970
971 query associated_item(key: DefId) -> ty::AssocItem {
973 desc { |tcx| "computing associated item data for `{}`", tcx.def_path_str(key) }
974 cache_on_disk_if { key.is_local() }
975 separate_provide_extern
976 feedable
977 }
978
979 query associated_items(key: DefId) -> &'tcx ty::AssocItems {
981 arena_cache
982 desc { |tcx| "collecting associated items of `{}`", tcx.def_path_str(key) }
983 }
984
985 query impl_item_implementor_ids(impl_id: DefId) -> &'tcx DefIdMap<DefId> {
1007 arena_cache
1008 desc { |tcx| "comparing impl items against trait for `{}`", tcx.def_path_str(impl_id) }
1009 }
1010
1011 query associated_types_for_impl_traits_in_associated_fn(fn_def_id: DefId) -> &'tcx [DefId] {
1018 desc { |tcx| "creating associated items for opaque types returned by `{}`", tcx.def_path_str(fn_def_id) }
1019 cache_on_disk_if { fn_def_id.is_local() }
1020 separate_provide_extern
1021 }
1022
1023 query associated_type_for_impl_trait_in_trait(opaque_ty_def_id: LocalDefId) -> LocalDefId {
1026 desc { |tcx| "creating the associated item corresponding to the opaque type `{}`", tcx.def_path_str(opaque_ty_def_id.to_def_id()) }
1027 cache_on_disk_if { true }
1028 }
1029
1030 query impl_trait_header(impl_id: DefId) -> Option<ty::ImplTraitHeader<'tcx>> {
1033 desc { |tcx| "computing trait implemented by `{}`", tcx.def_path_str(impl_id) }
1034 cache_on_disk_if { impl_id.is_local() }
1035 separate_provide_extern
1036 }
1037
1038 query impl_self_is_guaranteed_unsized(impl_def_id: DefId) -> bool {
1042 desc { |tcx| "computing whether `{}` has a guaranteed unsized self type", tcx.def_path_str(impl_def_id) }
1043 }
1044
1045 query inherent_impls(key: DefId) -> &'tcx [DefId] {
1049 desc { |tcx| "collecting inherent impls for `{}`", tcx.def_path_str(key) }
1050 cache_on_disk_if { key.is_local() }
1051 separate_provide_extern
1052 }
1053
1054 query incoherent_impls(key: SimplifiedType) -> &'tcx [DefId] {
1055 desc { |tcx| "collecting all inherent impls for `{:?}`", key }
1056 }
1057
1058 query check_unsafety(key: LocalDefId) {
1060 desc { |tcx| "unsafety-checking `{}`", tcx.def_path_str(key) }
1061 }
1062
1063 query check_tail_calls(key: LocalDefId) -> Result<(), rustc_errors::ErrorGuaranteed> {
1065 desc { |tcx| "tail-call-checking `{}`", tcx.def_path_str(key) }
1066 return_result_from_ensure_ok
1067 }
1068
1069 query assumed_wf_types(key: LocalDefId) -> &'tcx [(Ty<'tcx>, Span)] {
1074 desc { |tcx| "computing the implied bounds of `{}`", tcx.def_path_str(key) }
1075 }
1076
1077 query assumed_wf_types_for_rpitit(key: DefId) -> &'tcx [(Ty<'tcx>, Span)] {
1080 desc { |tcx| "computing the implied bounds of `{}`", tcx.def_path_str(key) }
1081 separate_provide_extern
1082 }
1083
1084 query fn_sig(key: DefId) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
1086 desc { |tcx| "computing function signature of `{}`", tcx.def_path_str(key) }
1087 cache_on_disk_if { key.is_local() }
1088 separate_provide_extern
1089 cycle_delay_bug
1090 }
1091
1092 query lint_mod(key: LocalModDefId) {
1094 desc { |tcx| "linting {}", describe_as_module(key, tcx) }
1095 }
1096
1097 query check_unused_traits(_: ()) {
1098 desc { "checking unused trait imports in crate" }
1099 }
1100
1101 query check_mod_attrs(key: LocalModDefId) {
1103 desc { |tcx| "checking attributes in {}", describe_as_module(key, tcx) }
1104 }
1105
1106 query check_mod_unstable_api_usage(key: LocalModDefId) {
1108 desc { |tcx| "checking for unstable API usage in {}", describe_as_module(key, tcx) }
1109 }
1110
1111 query check_mod_loops(key: LocalModDefId) {
1113 desc { |tcx| "checking loops in {}", describe_as_module(key, tcx) }
1114 }
1115
1116 query check_mod_naked_functions(key: LocalModDefId) {
1117 desc { |tcx| "checking naked functions in {}", describe_as_module(key, tcx) }
1118 }
1119
1120 query check_mod_privacy(key: LocalModDefId) {
1121 desc { |tcx| "checking privacy in {}", describe_as_module(key.to_local_def_id(), tcx) }
1122 }
1123
1124 query check_liveness(key: LocalDefId) {
1125 desc { |tcx| "checking liveness of variables in `{}`", tcx.def_path_str(key) }
1126 }
1127
1128 query live_symbols_and_ignored_derived_traits(_: ()) -> &'tcx (
1133 LocalDefIdSet,
1134 LocalDefIdMap<Vec<(DefId, DefId)>>
1135 ) {
1136 arena_cache
1137 desc { "finding live symbols in crate" }
1138 }
1139
1140 query check_mod_deathness(key: LocalModDefId) {
1141 desc { |tcx| "checking deathness of variables in {}", describe_as_module(key, tcx) }
1142 }
1143
1144 query check_mod_type_wf(key: LocalModDefId) -> Result<(), ErrorGuaranteed> {
1145 desc { |tcx| "checking that types are well-formed in {}", describe_as_module(key, tcx) }
1146 return_result_from_ensure_ok
1147 }
1148
1149 query coerce_unsized_info(key: DefId) -> Result<ty::adjustment::CoerceUnsizedInfo, ErrorGuaranteed> {
1151 desc { |tcx| "computing CoerceUnsized info for `{}`", tcx.def_path_str(key) }
1152 cache_on_disk_if { key.is_local() }
1153 separate_provide_extern
1154 return_result_from_ensure_ok
1155 }
1156
1157 query typeck(key: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
1158 desc { |tcx| "type-checking `{}`", tcx.def_path_str(key) }
1159 cache_on_disk_if(tcx) { !tcx.is_typeck_child(key.to_def_id()) }
1160 }
1161
1162 query used_trait_imports(key: LocalDefId) -> &'tcx UnordSet<LocalDefId> {
1163 desc { |tcx| "finding used_trait_imports `{}`", tcx.def_path_str(key) }
1164 cache_on_disk_if { true }
1165 }
1166
1167 query coherent_trait(def_id: DefId) -> Result<(), ErrorGuaranteed> {
1168 desc { |tcx| "coherence checking all impls of trait `{}`", tcx.def_path_str(def_id) }
1169 return_result_from_ensure_ok
1170 }
1171
1172 query mir_borrowck(key: LocalDefId) -> Result<&'tcx mir::ConcreteOpaqueTypes<'tcx>, ErrorGuaranteed> {
1175 desc { |tcx| "borrow-checking `{}`", tcx.def_path_str(key) }
1176 }
1177
1178 query crate_inherent_impls(k: ()) -> (&'tcx CrateInherentImpls, Result<(), ErrorGuaranteed>) {
1186 desc { "finding all inherent impls defined in crate" }
1187 }
1188
1189 query crate_inherent_impls_validity_check(_: ()) -> Result<(), ErrorGuaranteed> {
1197 desc { "check for inherent impls that should not be defined in crate" }
1198 return_result_from_ensure_ok
1199 }
1200
1201 query crate_inherent_impls_overlap_check(_: ()) -> Result<(), ErrorGuaranteed> {
1209 desc { "check for overlap between inherent impls defined in this crate" }
1210 return_result_from_ensure_ok
1211 }
1212
1213 query orphan_check_impl(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
1216 desc { |tcx|
1217 "checking whether impl `{}` follows the orphan rules",
1218 tcx.def_path_str(key),
1219 }
1220 return_result_from_ensure_ok
1221 }
1222
1223 query mir_callgraph_reachable(key: (ty::Instance<'tcx>, LocalDefId)) -> bool {
1226 fatal_cycle
1227 desc { |tcx|
1228 "computing if `{}` (transitively) calls `{}`",
1229 key.0,
1230 tcx.def_path_str(key.1),
1231 }
1232 }
1233
1234 query mir_inliner_callees(key: ty::InstanceKind<'tcx>) -> &'tcx [(DefId, GenericArgsRef<'tcx>)] {
1236 fatal_cycle
1237 desc { |tcx|
1238 "computing all local function calls in `{}`",
1239 tcx.def_path_str(key.def_id()),
1240 }
1241 }
1242
1243 query tag_for_variant(
1251 key: (Ty<'tcx>, abi::VariantIdx)
1252 ) -> Option<ty::ScalarInt> {
1253 desc { "computing variant tag for enum" }
1254 }
1255
1256 query eval_to_allocation_raw(key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>)
1265 -> EvalToAllocationRawResult<'tcx> {
1266 desc { |tcx|
1267 "const-evaluating + checking `{}`",
1268 key.value.display(tcx)
1269 }
1270 cache_on_disk_if { true }
1271 }
1272
1273 query eval_static_initializer(key: DefId) -> EvalStaticInitializerRawResult<'tcx> {
1275 desc { |tcx|
1276 "evaluating initializer of static `{}`",
1277 tcx.def_path_str(key)
1278 }
1279 cache_on_disk_if { key.is_local() }
1280 separate_provide_extern
1281 feedable
1282 }
1283
1284 query eval_to_const_value_raw(key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>)
1297 -> EvalToConstValueResult<'tcx> {
1298 desc { |tcx|
1299 "simplifying constant for the type system `{}`",
1300 key.value.display(tcx)
1301 }
1302 depth_limit
1303 cache_on_disk_if { true }
1304 }
1305
1306 query eval_to_valtree(
1309 key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>
1310 ) -> EvalToValTreeResult<'tcx> {
1311 desc { "evaluating type-level constant" }
1312 }
1313
1314 query valtree_to_const_val(key: ty::Value<'tcx>) -> mir::ConstValue<'tcx> {
1316 desc { "converting type-level constant value to MIR constant value"}
1317 }
1318
1319 query destructure_const(key: ty::Const<'tcx>) -> ty::DestructuredConst<'tcx> {
1322 desc { "destructuring type level constant"}
1323 }
1324
1325 query lit_to_const(
1327 key: LitToConstInput<'tcx>
1328 ) -> ty::Const<'tcx> {
1329 desc { "converting literal to const" }
1330 }
1331
1332 query check_match(key: LocalDefId) -> Result<(), rustc_errors::ErrorGuaranteed> {
1333 desc { |tcx| "match-checking `{}`", tcx.def_path_str(key) }
1334 return_result_from_ensure_ok
1335 }
1336
1337 query effective_visibilities(_: ()) -> &'tcx EffectiveVisibilities {
1339 eval_always
1340 desc { "checking effective visibilities" }
1341 }
1342 query check_private_in_public(_: ()) {
1343 eval_always
1344 desc { "checking for private elements in public interfaces" }
1345 }
1346
1347 query reachable_set(_: ()) -> &'tcx LocalDefIdSet {
1348 arena_cache
1349 desc { "reachability" }
1350 cache_on_disk_if { true }
1351 }
1352
1353 query region_scope_tree(def_id: DefId) -> &'tcx crate::middle::region::ScopeTree {
1356 desc { |tcx| "computing drop scopes for `{}`", tcx.def_path_str(def_id) }
1357 }
1358
1359 query mir_shims(key: ty::InstanceKind<'tcx>) -> &'tcx mir::Body<'tcx> {
1361 arena_cache
1362 desc {
1363 |tcx| "generating MIR shim for `{}`, instance={:?}",
1364 tcx.def_path_str(key.def_id()),
1365 key
1366 }
1367 }
1368
1369 query symbol_name(key: ty::Instance<'tcx>) -> ty::SymbolName<'tcx> {
1373 desc { "computing the symbol for `{}`", key }
1374 cache_on_disk_if { true }
1375 }
1376
1377 query def_kind(def_id: DefId) -> DefKind {
1378 desc { |tcx| "looking up definition kind of `{}`", tcx.def_path_str(def_id) }
1379 cache_on_disk_if { def_id.is_local() }
1380 separate_provide_extern
1381 feedable
1382 }
1383
1384 query def_span(def_id: DefId) -> Span {
1386 desc { |tcx| "looking up span for `{}`", tcx.def_path_str(def_id) }
1387 cache_on_disk_if { def_id.is_local() }
1388 separate_provide_extern
1389 feedable
1390 }
1391
1392 query def_ident_span(def_id: DefId) -> Option<Span> {
1394 desc { |tcx| "looking up span for `{}`'s identifier", tcx.def_path_str(def_id) }
1395 cache_on_disk_if { def_id.is_local() }
1396 separate_provide_extern
1397 feedable
1398 }
1399
1400 query lookup_stability(def_id: DefId) -> Option<attr::Stability> {
1401 desc { |tcx| "looking up stability of `{}`", tcx.def_path_str(def_id) }
1402 cache_on_disk_if { def_id.is_local() }
1403 separate_provide_extern
1404 }
1405
1406 query lookup_const_stability(def_id: DefId) -> Option<attr::ConstStability> {
1407 desc { |tcx| "looking up const stability of `{}`", tcx.def_path_str(def_id) }
1408 cache_on_disk_if { def_id.is_local() }
1409 separate_provide_extern
1410 }
1411
1412 query lookup_default_body_stability(def_id: DefId) -> Option<attr::DefaultBodyStability> {
1413 desc { |tcx| "looking up default body stability of `{}`", tcx.def_path_str(def_id) }
1414 separate_provide_extern
1415 }
1416
1417 query should_inherit_track_caller(def_id: DefId) -> bool {
1418 desc { |tcx| "computing should_inherit_track_caller of `{}`", tcx.def_path_str(def_id) }
1419 }
1420
1421 query lookup_deprecation_entry(def_id: DefId) -> Option<DeprecationEntry> {
1422 desc { |tcx| "checking whether `{}` is deprecated", tcx.def_path_str(def_id) }
1423 cache_on_disk_if { def_id.is_local() }
1424 separate_provide_extern
1425 }
1426
1427 query is_doc_hidden(def_id: DefId) -> bool {
1429 desc { |tcx| "checking whether `{}` is `doc(hidden)`", tcx.def_path_str(def_id) }
1430 separate_provide_extern
1431 }
1432
1433 query is_doc_notable_trait(def_id: DefId) -> bool {
1435 desc { |tcx| "checking whether `{}` is `doc(notable_trait)`", tcx.def_path_str(def_id) }
1436 }
1437
1438 query attrs_for_def(def_id: DefId) -> &'tcx [hir::Attribute] {
1442 desc { |tcx| "collecting attributes of `{}`", tcx.def_path_str(def_id) }
1443 separate_provide_extern
1444 }
1445
1446 query codegen_fn_attrs(def_id: DefId) -> &'tcx CodegenFnAttrs {
1447 desc { |tcx| "computing codegen attributes of `{}`", tcx.def_path_str(def_id) }
1448 arena_cache
1449 cache_on_disk_if { def_id.is_local() }
1450 separate_provide_extern
1451 feedable
1452 }
1453
1454 query asm_target_features(def_id: DefId) -> &'tcx FxIndexSet<Symbol> {
1455 desc { |tcx| "computing target features for inline asm of `{}`", tcx.def_path_str(def_id) }
1456 }
1457
1458 query fn_arg_idents(def_id: DefId) -> &'tcx [Option<rustc_span::Ident>] {
1459 desc { |tcx| "looking up function parameter identifiers for `{}`", tcx.def_path_str(def_id) }
1460 separate_provide_extern
1461 }
1462
1463 query rendered_const(def_id: DefId) -> &'tcx String {
1466 arena_cache
1467 desc { |tcx| "rendering constant initializer of `{}`", tcx.def_path_str(def_id) }
1468 separate_provide_extern
1469 }
1470
1471 query rendered_precise_capturing_args(def_id: DefId) -> Option<&'tcx [PreciseCapturingArgKind<Symbol, Symbol>]> {
1473 desc { |tcx| "rendering precise capturing args for `{}`", tcx.def_path_str(def_id) }
1474 separate_provide_extern
1475 }
1476
1477 query impl_parent(def_id: DefId) -> Option<DefId> {
1478 desc { |tcx| "computing specialization parent impl of `{}`", tcx.def_path_str(def_id) }
1479 separate_provide_extern
1480 }
1481
1482 query is_ctfe_mir_available(key: DefId) -> bool {
1483 desc { |tcx| "checking if item has CTFE MIR available: `{}`", tcx.def_path_str(key) }
1484 cache_on_disk_if { key.is_local() }
1485 separate_provide_extern
1486 }
1487 query is_mir_available(key: DefId) -> bool {
1488 desc { |tcx| "checking if item has MIR available: `{}`", tcx.def_path_str(key) }
1489 cache_on_disk_if { key.is_local() }
1490 separate_provide_extern
1491 }
1492
1493 query own_existential_vtable_entries(
1494 key: DefId
1495 ) -> &'tcx [DefId] {
1496 desc { |tcx| "finding all existential vtable entries for trait `{}`", tcx.def_path_str(key) }
1497 }
1498
1499 query vtable_entries(key: ty::TraitRef<'tcx>)
1500 -> &'tcx [ty::VtblEntry<'tcx>] {
1501 desc { |tcx| "finding all vtable entries for trait `{}`", tcx.def_path_str(key.def_id) }
1502 }
1503
1504 query first_method_vtable_slot(key: ty::TraitRef<'tcx>) -> usize {
1505 desc { |tcx| "finding the slot within the vtable of `{}` for the implementation of `{}`", key.self_ty(), key.print_only_trait_name() }
1506 }
1507
1508 query supertrait_vtable_slot(key: (Ty<'tcx>, Ty<'tcx>)) -> Option<usize> {
1509 desc { |tcx| "finding the slot within vtable for trait object `{}` vtable ptr during trait upcasting coercion from `{}` vtable",
1510 key.1, key.0 }
1511 }
1512
1513 query vtable_allocation(key: (Ty<'tcx>, Option<ty::ExistentialTraitRef<'tcx>>)) -> mir::interpret::AllocId {
1514 desc { |tcx| "vtable const allocation for <{} as {}>",
1515 key.0,
1516 key.1.map(|trait_ref| format!("{trait_ref}")).unwrap_or("_".to_owned())
1517 }
1518 }
1519
1520 query codegen_select_candidate(
1521 key: PseudoCanonicalInput<'tcx, ty::TraitRef<'tcx>>
1522 ) -> Result<&'tcx ImplSource<'tcx, ()>, CodegenObligationError> {
1523 cache_on_disk_if { true }
1524 desc { |tcx| "computing candidate for `{}`", key.value }
1525 }
1526
1527 query all_local_trait_impls(_: ()) -> &'tcx rustc_data_structures::fx::FxIndexMap<DefId, Vec<LocalDefId>> {
1529 desc { "finding local trait impls" }
1530 }
1531
1532 query local_trait_impls(trait_id: DefId) -> &'tcx [LocalDefId] {
1534 desc { "finding local trait impls of `{}`", tcx.def_path_str(trait_id) }
1535 }
1536
1537 query trait_impls_of(trait_id: DefId) -> &'tcx ty::trait_def::TraitImpls {
1539 arena_cache
1540 desc { |tcx| "finding trait impls of `{}`", tcx.def_path_str(trait_id) }
1541 }
1542
1543 query specialization_graph_of(trait_id: DefId) -> Result<&'tcx specialization_graph::Graph, ErrorGuaranteed> {
1544 desc { |tcx| "building specialization graph of trait `{}`", tcx.def_path_str(trait_id) }
1545 cache_on_disk_if { true }
1546 return_result_from_ensure_ok
1547 }
1548 query dyn_compatibility_violations(trait_id: DefId) -> &'tcx [DynCompatibilityViolation] {
1549 desc { |tcx| "determining dyn-compatibility of trait `{}`", tcx.def_path_str(trait_id) }
1550 }
1551 query is_dyn_compatible(trait_id: DefId) -> bool {
1552 desc { |tcx| "checking if trait `{}` is dyn-compatible", tcx.def_path_str(trait_id) }
1553 }
1554
1555 query param_env(def_id: DefId) -> ty::ParamEnv<'tcx> {
1564 desc { |tcx| "computing normalized predicates of `{}`", tcx.def_path_str(def_id) }
1565 feedable
1566 }
1567
1568 query param_env_normalized_for_post_analysis(def_id: DefId) -> ty::ParamEnv<'tcx> {
1572 desc { |tcx| "computing revealed normalized predicates of `{}`", tcx.def_path_str(def_id) }
1573 }
1574
1575 query is_copy_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1578 desc { "computing whether `{}` is `Copy`", env.value }
1579 }
1580 query is_use_cloned_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1583 desc { "computing whether `{}` is `UseCloned`", env.value }
1584 }
1585 query is_sized_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1587 desc { "computing whether `{}` is `Sized`", env.value }
1588 }
1589 query is_freeze_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1591 desc { "computing whether `{}` is freeze", env.value }
1592 }
1593 query is_unpin_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1595 desc { "computing whether `{}` is `Unpin`", env.value }
1596 }
1597 query is_async_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1599 desc { "computing whether `{}` is `AsyncDrop`", env.value }
1600 }
1601 query needs_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1603 desc { "computing whether `{}` needs drop", env.value }
1604 }
1605 query needs_async_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1607 desc { "computing whether `{}` needs async drop", env.value }
1608 }
1609 query has_significant_drop_raw(env: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
1611 desc { "computing whether `{}` has a significant drop", env.value }
1612 }
1613
1614 query has_structural_eq_impl(ty: Ty<'tcx>) -> bool {
1619 desc {
1620 "computing whether `{}` implements `StructuralPartialEq`",
1621 ty
1622 }
1623 }
1624
1625 query adt_drop_tys(def_id: DefId) -> Result<&'tcx ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
1629 desc { |tcx| "computing when `{}` needs drop", tcx.def_path_str(def_id) }
1630 cache_on_disk_if { true }
1631 }
1632
1633 query adt_async_drop_tys(def_id: DefId) -> Result<&'tcx ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
1637 desc { |tcx| "computing when `{}` needs async drop", tcx.def_path_str(def_id) }
1638 cache_on_disk_if { true }
1639 }
1640
1641 query adt_significant_drop_tys(def_id: DefId) -> Result<&'tcx ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
1648 desc { |tcx| "computing when `{}` has a significant destructor", tcx.def_path_str(def_id) }
1649 }
1650
1651 query list_significant_drop_tys(ty: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> &'tcx ty::List<Ty<'tcx>> {
1669 desc { |tcx| "computing when `{}` has a significant destructor", ty.value }
1670 }
1671
1672 query layout_of(
1675 key: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>
1676 ) -> Result<ty::layout::TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
1677 depth_limit
1678 desc { "computing layout of `{}`", key.value }
1679 cycle_delay_bug
1681 }
1682
1683 query fn_abi_of_fn_ptr(
1688 key: ty::PseudoCanonicalInput<'tcx, (ty::PolyFnSig<'tcx>, &'tcx ty::List<Ty<'tcx>>)>
1689 ) -> Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, &'tcx ty::layout::FnAbiError<'tcx>> {
1690 desc { "computing call ABI of `{}` function pointers", key.value.0 }
1691 }
1692
1693 query fn_abi_of_instance(
1699 key: ty::PseudoCanonicalInput<'tcx, (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>)>
1700 ) -> Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, &'tcx ty::layout::FnAbiError<'tcx>> {
1701 desc { "computing call ABI of `{}`", key.value.0 }
1702 }
1703
1704 query dylib_dependency_formats(_: CrateNum)
1705 -> &'tcx [(CrateNum, LinkagePreference)] {
1706 desc { "getting dylib dependency formats of crate" }
1707 separate_provide_extern
1708 }
1709
1710 query dependency_formats(_: ()) -> &'tcx Arc<crate::middle::dependency_format::Dependencies> {
1711 arena_cache
1712 desc { "getting the linkage format of all dependencies" }
1713 }
1714
1715 query is_compiler_builtins(_: CrateNum) -> bool {
1716 fatal_cycle
1717 desc { "checking if the crate is_compiler_builtins" }
1718 separate_provide_extern
1719 }
1720 query has_global_allocator(_: CrateNum) -> bool {
1721 eval_always
1723 fatal_cycle
1724 desc { "checking if the crate has_global_allocator" }
1725 separate_provide_extern
1726 }
1727 query has_alloc_error_handler(_: CrateNum) -> bool {
1728 eval_always
1730 fatal_cycle
1731 desc { "checking if the crate has_alloc_error_handler" }
1732 separate_provide_extern
1733 }
1734 query has_panic_handler(_: CrateNum) -> bool {
1735 fatal_cycle
1736 desc { "checking if the crate has_panic_handler" }
1737 separate_provide_extern
1738 }
1739 query is_profiler_runtime(_: CrateNum) -> bool {
1740 fatal_cycle
1741 desc { "checking if a crate is `#![profiler_runtime]`" }
1742 separate_provide_extern
1743 }
1744 query has_ffi_unwind_calls(key: LocalDefId) -> bool {
1745 desc { |tcx| "checking if `{}` contains FFI-unwind calls", tcx.def_path_str(key) }
1746 cache_on_disk_if { true }
1747 }
1748 query required_panic_strategy(_: CrateNum) -> Option<PanicStrategy> {
1749 fatal_cycle
1750 desc { "getting a crate's required panic strategy" }
1751 separate_provide_extern
1752 }
1753 query panic_in_drop_strategy(_: CrateNum) -> PanicStrategy {
1754 fatal_cycle
1755 desc { "getting a crate's configured panic-in-drop strategy" }
1756 separate_provide_extern
1757 }
1758 query is_no_builtins(_: CrateNum) -> bool {
1759 fatal_cycle
1760 desc { "getting whether a crate has `#![no_builtins]`" }
1761 separate_provide_extern
1762 }
1763 query symbol_mangling_version(_: CrateNum) -> SymbolManglingVersion {
1764 fatal_cycle
1765 desc { "getting a crate's symbol mangling version" }
1766 separate_provide_extern
1767 }
1768
1769 query extern_crate(def_id: CrateNum) -> Option<&'tcx ExternCrate> {
1770 eval_always
1771 desc { "getting crate's ExternCrateData" }
1772 separate_provide_extern
1773 }
1774
1775 query specialization_enabled_in(cnum: CrateNum) -> bool {
1776 desc { "checking whether the crate enabled `specialization`/`min_specialization`" }
1777 separate_provide_extern
1778 }
1779
1780 query specializes(_: (DefId, DefId)) -> bool {
1781 desc { "computing whether impls specialize one another" }
1782 }
1783 query in_scope_traits_map(_: hir::OwnerId)
1784 -> Option<&'tcx ItemLocalMap<Box<[TraitCandidate]>>> {
1785 desc { "getting traits in scope at a block" }
1786 }
1787
1788 query defaultness(def_id: DefId) -> hir::Defaultness {
1790 desc { |tcx| "looking up whether `{}` has `default`", tcx.def_path_str(def_id) }
1791 separate_provide_extern
1792 feedable
1793 }
1794
1795 query check_well_formed(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
1796 desc { |tcx| "checking that `{}` is well-formed", tcx.def_path_str(key) }
1797 return_result_from_ensure_ok
1798 }
1799
1800 query enforce_impl_non_lifetime_params_are_constrained(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
1801 desc { |tcx| "checking that `{}`'s generics are constrained by the impl header", tcx.def_path_str(key) }
1802 return_result_from_ensure_ok
1803 }
1804
1805 query reachable_non_generics(_: CrateNum)
1818 -> &'tcx DefIdMap<SymbolExportInfo> {
1819 arena_cache
1820 desc { "looking up the exported symbols of a crate" }
1821 separate_provide_extern
1822 }
1823 query is_reachable_non_generic(def_id: DefId) -> bool {
1824 desc { |tcx| "checking whether `{}` is an exported symbol", tcx.def_path_str(def_id) }
1825 cache_on_disk_if { def_id.is_local() }
1826 separate_provide_extern
1827 }
1828 query is_unreachable_local_definition(def_id: LocalDefId) -> bool {
1829 desc { |tcx|
1830 "checking whether `{}` is reachable from outside the crate",
1831 tcx.def_path_str(def_id),
1832 }
1833 }
1834
1835 query upstream_monomorphizations(_: ()) -> &'tcx DefIdMap<UnordMap<GenericArgsRef<'tcx>, CrateNum>> {
1843 arena_cache
1844 desc { "collecting available upstream monomorphizations" }
1845 }
1846
1847 query upstream_monomorphizations_for(def_id: DefId)
1855 -> Option<&'tcx UnordMap<GenericArgsRef<'tcx>, CrateNum>>
1856 {
1857 desc { |tcx|
1858 "collecting available upstream monomorphizations for `{}`",
1859 tcx.def_path_str(def_id),
1860 }
1861 separate_provide_extern
1862 }
1863
1864 query upstream_drop_glue_for(args: GenericArgsRef<'tcx>) -> Option<CrateNum> {
1880 desc { "available upstream drop-glue for `{:?}`", args }
1881 }
1882
1883 query upstream_async_drop_glue_for(args: GenericArgsRef<'tcx>) -> Option<CrateNum> {
1900 desc { "available upstream async-drop-glue for `{:?}`", args }
1901 }
1902
1903 query foreign_modules(_: CrateNum) -> &'tcx FxIndexMap<DefId, ForeignModule> {
1905 arena_cache
1906 desc { "looking up the foreign modules of a linked crate" }
1907 separate_provide_extern
1908 }
1909
1910 query clashing_extern_declarations(_: ()) {
1912 desc { "checking `extern fn` declarations are compatible" }
1913 }
1914
1915 query entry_fn(_: ()) -> Option<(DefId, EntryFnType)> {
1918 desc { "looking up the entry function of a crate" }
1919 }
1920
1921 query proc_macro_decls_static(_: ()) -> Option<LocalDefId> {
1923 desc { "looking up the proc macro declarations for a crate" }
1924 }
1925
1926 query crate_hash(_: CrateNum) -> Svh {
1934 eval_always
1935 desc { "looking up the hash a crate" }
1936 separate_provide_extern
1937 }
1938
1939 query crate_host_hash(_: CrateNum) -> Option<Svh> {
1941 eval_always
1942 desc { "looking up the hash of a host version of a crate" }
1943 separate_provide_extern
1944 }
1945
1946 query extra_filename(_: CrateNum) -> &'tcx String {
1949 arena_cache
1950 eval_always
1951 desc { "looking up the extra filename for a crate" }
1952 separate_provide_extern
1953 }
1954
1955 query crate_extern_paths(_: CrateNum) -> &'tcx Vec<PathBuf> {
1957 arena_cache
1958 eval_always
1959 desc { "looking up the paths for extern crates" }
1960 separate_provide_extern
1961 }
1962
1963 query implementations_of_trait(_: (CrateNum, DefId)) -> &'tcx [(DefId, Option<SimplifiedType>)] {
1966 desc { "looking up implementations of a trait in a crate" }
1967 separate_provide_extern
1968 }
1969
1970 query crate_incoherent_impls(key: (CrateNum, SimplifiedType)) -> &'tcx [DefId] {
1975 desc { |tcx| "collecting all impls for a type in a crate" }
1976 separate_provide_extern
1977 }
1978
1979 query native_library(def_id: DefId) -> Option<&'tcx NativeLib> {
1981 desc { |tcx| "getting the native library for `{}`", tcx.def_path_str(def_id) }
1982 }
1983
1984 query inherit_sig_for_delegation_item(def_id: LocalDefId) -> &'tcx [Ty<'tcx>] {
1985 desc { "inheriting delegation signature" }
1986 }
1987
1988 query resolve_bound_vars(owner_id: hir::OwnerId) -> &'tcx ResolveBoundVars {
1992 arena_cache
1993 desc { |tcx| "resolving lifetimes for `{}`", tcx.def_path_str(owner_id) }
1994 }
1995 query named_variable_map(owner_id: hir::OwnerId) -> &'tcx SortedMap<ItemLocalId, ResolvedArg> {
1996 desc { |tcx| "looking up a named region inside `{}`", tcx.def_path_str(owner_id) }
1997 }
1998 query is_late_bound_map(owner_id: hir::OwnerId) -> Option<&'tcx FxIndexSet<ItemLocalId>> {
1999 desc { |tcx| "testing if a region is late bound inside `{}`", tcx.def_path_str(owner_id) }
2000 }
2001 query object_lifetime_default(def_id: DefId) -> ObjectLifetimeDefault {
2016 desc { "looking up lifetime defaults for type parameter `{}`", tcx.def_path_str(def_id) }
2017 separate_provide_extern
2018 }
2019 query late_bound_vars_map(owner_id: hir::OwnerId)
2020 -> &'tcx SortedMap<ItemLocalId, Vec<ty::BoundVariableKind>> {
2021 desc { |tcx| "looking up late bound vars inside `{}`", tcx.def_path_str(owner_id) }
2022 }
2023 query opaque_captured_lifetimes(def_id: LocalDefId) -> &'tcx [(ResolvedArg, LocalDefId)] {
2038 desc { |tcx| "listing captured lifetimes for opaque `{}`", tcx.def_path_str(def_id) }
2039 }
2040
2041 query visibility(def_id: DefId) -> ty::Visibility<DefId> {
2054 desc { |tcx| "computing visibility of `{}`", tcx.def_path_str(def_id) }
2055 separate_provide_extern
2056 feedable
2057 }
2058
2059 query inhabited_predicate_adt(key: DefId) -> ty::inhabitedness::InhabitedPredicate<'tcx> {
2060 desc { "computing the uninhabited predicate of `{:?}`", key }
2061 }
2062
2063 query inhabited_predicate_type(key: Ty<'tcx>) -> ty::inhabitedness::InhabitedPredicate<'tcx> {
2065 desc { "computing the uninhabited predicate of `{}`", key }
2066 }
2067
2068 query dep_kind(_: CrateNum) -> CrateDepKind {
2069 eval_always
2070 desc { "fetching what a dependency looks like" }
2071 separate_provide_extern
2072 }
2073
2074 query crate_name(_: CrateNum) -> Symbol {
2076 feedable
2077 desc { "fetching what a crate is named" }
2078 separate_provide_extern
2079 }
2080 query module_children(def_id: DefId) -> &'tcx [ModChild] {
2081 desc { |tcx| "collecting child items of module `{}`", tcx.def_path_str(def_id) }
2082 separate_provide_extern
2083 }
2084 query extern_mod_stmt_cnum(def_id: LocalDefId) -> Option<CrateNum> {
2085 desc { |tcx| "computing crate imported by `{}`", tcx.def_path_str(def_id) }
2086 }
2087
2088 query num_extern_def_ids(_: CrateNum) -> usize {
2094 desc { "fetching the number of definitions in a crate" }
2095 separate_provide_extern
2096 }
2097
2098 query lib_features(_: CrateNum) -> &'tcx LibFeatures {
2099 desc { "calculating the lib features defined in a crate" }
2100 separate_provide_extern
2101 arena_cache
2102 }
2103 query stability_implications(_: CrateNum) -> &'tcx UnordMap<Symbol, Symbol> {
2104 arena_cache
2105 desc { "calculating the implications between `#[unstable]` features defined in a crate" }
2106 separate_provide_extern
2107 }
2108 query intrinsic_raw(def_id: DefId) -> Option<rustc_middle::ty::IntrinsicDef> {
2110 desc { |tcx| "fetch intrinsic name if `{}` is an intrinsic", tcx.def_path_str(def_id) }
2111 separate_provide_extern
2112 }
2113 query get_lang_items(_: ()) -> &'tcx LanguageItems {
2115 arena_cache
2116 eval_always
2117 desc { "calculating the lang items map" }
2118 }
2119
2120 query all_diagnostic_items(_: ()) -> &'tcx rustc_hir::diagnostic_items::DiagnosticItems {
2122 arena_cache
2123 eval_always
2124 desc { "calculating the diagnostic items map" }
2125 }
2126
2127 query defined_lang_items(_: CrateNum) -> &'tcx [(DefId, LangItem)] {
2129 desc { "calculating the lang items defined in a crate" }
2130 separate_provide_extern
2131 }
2132
2133 query diagnostic_items(_: CrateNum) -> &'tcx rustc_hir::diagnostic_items::DiagnosticItems {
2135 arena_cache
2136 desc { "calculating the diagnostic items map in a crate" }
2137 separate_provide_extern
2138 }
2139
2140 query missing_lang_items(_: CrateNum) -> &'tcx [LangItem] {
2141 desc { "calculating the missing lang items in a crate" }
2142 separate_provide_extern
2143 }
2144
2145 query visible_parent_map(_: ()) -> &'tcx DefIdMap<DefId> {
2150 arena_cache
2151 desc { "calculating the visible parent map" }
2152 }
2153 query trimmed_def_paths(_: ()) -> &'tcx DefIdMap<Symbol> {
2156 arena_cache
2157 desc { "calculating trimmed def paths" }
2158 }
2159 query missing_extern_crate_item(_: CrateNum) -> bool {
2160 eval_always
2161 desc { "seeing if we're missing an `extern crate` item for this crate" }
2162 separate_provide_extern
2163 }
2164 query used_crate_source(_: CrateNum) -> &'tcx Arc<CrateSource> {
2165 arena_cache
2166 eval_always
2167 desc { "looking at the source for a crate" }
2168 separate_provide_extern
2169 }
2170
2171 query debugger_visualizers(_: CrateNum) -> &'tcx Vec<DebuggerVisualizerFile> {
2176 arena_cache
2177 desc { "looking up the debugger visualizers for this crate" }
2178 separate_provide_extern
2179 eval_always
2180 }
2181
2182 query postorder_cnums(_: ()) -> &'tcx [CrateNum] {
2183 eval_always
2184 desc { "generating a postorder list of CrateNums" }
2185 }
2186 query is_private_dep(c: CrateNum) -> bool {
2189 eval_always
2190 desc { "checking whether crate `{}` is a private dependency", c }
2191 separate_provide_extern
2192 }
2193 query allocator_kind(_: ()) -> Option<AllocatorKind> {
2194 eval_always
2195 desc { "getting the allocator kind for the current crate" }
2196 }
2197 query alloc_error_handler_kind(_: ()) -> Option<AllocatorKind> {
2198 eval_always
2199 desc { "alloc error handler kind for the current crate" }
2200 }
2201
2202 query upvars_mentioned(def_id: DefId) -> Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>> {
2203 desc { |tcx| "collecting upvars mentioned in `{}`", tcx.def_path_str(def_id) }
2204 }
2205 query maybe_unused_trait_imports(_: ()) -> &'tcx FxIndexSet<LocalDefId> {
2206 desc { "fetching potentially unused trait imports" }
2207 }
2208 query names_imported_by_glob_use(def_id: LocalDefId) -> &'tcx FxIndexSet<Symbol> {
2209 desc { |tcx| "finding names imported by glob use for `{}`", tcx.def_path_str(def_id) }
2210 }
2211
2212 query stability_index(_: ()) -> &'tcx stability::Index {
2213 arena_cache
2214 eval_always
2215 desc { "calculating the stability index for the local crate" }
2216 }
2217 query crates(_: ()) -> &'tcx [CrateNum] {
2220 eval_always
2221 desc { "fetching all foreign CrateNum instances" }
2222 }
2223 query used_crates(_: ()) -> &'tcx [CrateNum] {
2227 eval_always
2228 desc { "fetching `CrateNum`s for all crates loaded non-speculatively" }
2229 }
2230
2231 query traits(_: CrateNum) -> &'tcx [DefId] {
2233 desc { "fetching all traits in a crate" }
2234 separate_provide_extern
2235 }
2236
2237 query trait_impls_in_crate(_: CrateNum) -> &'tcx [DefId] {
2238 desc { "fetching all trait impls in a crate" }
2239 separate_provide_extern
2240 }
2241
2242 query stable_order_of_exportable_impls(_: CrateNum) -> &'tcx FxIndexMap<DefId, usize> {
2243 desc { "fetching the stable impl's order" }
2244 separate_provide_extern
2245 }
2246
2247 query exportable_items(_: CrateNum) -> &'tcx [DefId] {
2248 desc { "fetching all exportable items in a crate" }
2249 separate_provide_extern
2250 }
2251
2252 query exported_symbols(cnum: CrateNum) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)] {
2258 desc { "collecting exported symbols for crate `{}`", cnum}
2259 cache_on_disk_if { *cnum == LOCAL_CRATE }
2260 separate_provide_extern
2261 }
2262
2263 query collect_and_partition_mono_items(_: ()) -> MonoItemPartitions<'tcx> {
2264 eval_always
2265 desc { "collect_and_partition_mono_items" }
2266 }
2267
2268 query is_codegened_item(def_id: DefId) -> bool {
2269 desc { |tcx| "determining whether `{}` needs codegen", tcx.def_path_str(def_id) }
2270 }
2271
2272 query codegen_unit(sym: Symbol) -> &'tcx CodegenUnit<'tcx> {
2273 desc { "getting codegen unit `{sym}`" }
2274 }
2275
2276 query backend_optimization_level(_: ()) -> OptLevel {
2277 desc { "optimization level used by backend" }
2278 }
2279
2280 query output_filenames(_: ()) -> &'tcx Arc<OutputFilenames> {
2285 feedable
2286 desc { "getting output filenames" }
2287 arena_cache
2288 }
2289
2290 query normalize_canonicalized_projection_ty(
2296 goal: CanonicalAliasGoal<'tcx>
2297 ) -> Result<
2298 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, NormalizationResult<'tcx>>>,
2299 NoSolution,
2300 > {
2301 desc { "normalizing `{}`", goal.canonical.value.value }
2302 }
2303
2304 query normalize_canonicalized_free_alias(
2310 goal: CanonicalAliasGoal<'tcx>
2311 ) -> Result<
2312 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, NormalizationResult<'tcx>>>,
2313 NoSolution,
2314 > {
2315 desc { "normalizing `{}`", goal.canonical.value.value }
2316 }
2317
2318 query normalize_canonicalized_inherent_projection_ty(
2324 goal: CanonicalAliasGoal<'tcx>
2325 ) -> Result<
2326 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, NormalizationResult<'tcx>>>,
2327 NoSolution,
2328 > {
2329 desc { "normalizing `{}`", goal.canonical.value.value }
2330 }
2331
2332 query try_normalize_generic_arg_after_erasing_regions(
2334 goal: PseudoCanonicalInput<'tcx, GenericArg<'tcx>>
2335 ) -> Result<GenericArg<'tcx>, NoSolution> {
2336 desc { "normalizing `{}`", goal.value }
2337 }
2338
2339 query implied_outlives_bounds(
2340 key: (CanonicalImpliedOutlivesBoundsGoal<'tcx>, bool)
2341 ) -> Result<
2342 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>,
2343 NoSolution,
2344 > {
2345 desc { "computing implied outlives bounds for `{}` (hack disabled = {:?})", key.0.canonical.value.value.ty, key.1 }
2346 }
2347
2348 query dropck_outlives(
2351 goal: CanonicalDropckOutlivesGoal<'tcx>
2352 ) -> Result<
2353 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>,
2354 NoSolution,
2355 > {
2356 desc { "computing dropck types for `{}`", goal.canonical.value.value.dropped_ty }
2357 }
2358
2359 query evaluate_obligation(
2362 goal: CanonicalPredicateGoal<'tcx>
2363 ) -> Result<EvaluationResult, OverflowError> {
2364 desc { "evaluating trait selection obligation `{}`", goal.canonical.value.value }
2365 }
2366
2367 query type_op_ascribe_user_type(
2369 goal: CanonicalTypeOpAscribeUserTypeGoal<'tcx>
2370 ) -> Result<
2371 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ()>>,
2372 NoSolution,
2373 > {
2374 desc { "evaluating `type_op_ascribe_user_type` `{:?}`", goal.canonical.value.value }
2375 }
2376
2377 query type_op_prove_predicate(
2379 goal: CanonicalTypeOpProvePredicateGoal<'tcx>
2380 ) -> Result<
2381 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ()>>,
2382 NoSolution,
2383 > {
2384 desc { "evaluating `type_op_prove_predicate` `{:?}`", goal.canonical.value.value }
2385 }
2386
2387 query type_op_normalize_ty(
2389 goal: CanonicalTypeOpNormalizeGoal<'tcx, Ty<'tcx>>
2390 ) -> Result<
2391 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Ty<'tcx>>>,
2392 NoSolution,
2393 > {
2394 desc { "normalizing `{}`", goal.canonical.value.value.value }
2395 }
2396
2397 query type_op_normalize_clause(
2399 goal: CanonicalTypeOpNormalizeGoal<'tcx, ty::Clause<'tcx>>
2400 ) -> Result<
2401 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ty::Clause<'tcx>>>,
2402 NoSolution,
2403 > {
2404 desc { "normalizing `{:?}`", goal.canonical.value.value.value }
2405 }
2406
2407 query type_op_normalize_poly_fn_sig(
2409 goal: CanonicalTypeOpNormalizeGoal<'tcx, ty::PolyFnSig<'tcx>>
2410 ) -> Result<
2411 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ty::PolyFnSig<'tcx>>>,
2412 NoSolution,
2413 > {
2414 desc { "normalizing `{:?}`", goal.canonical.value.value.value }
2415 }
2416
2417 query type_op_normalize_fn_sig(
2419 goal: CanonicalTypeOpNormalizeGoal<'tcx, ty::FnSig<'tcx>>
2420 ) -> Result<
2421 &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ty::FnSig<'tcx>>>,
2422 NoSolution,
2423 > {
2424 desc { "normalizing `{:?}`", goal.canonical.value.value.value }
2425 }
2426
2427 query instantiate_and_check_impossible_predicates(key: (DefId, GenericArgsRef<'tcx>)) -> bool {
2428 desc { |tcx|
2429 "checking impossible instantiated predicates: `{}`",
2430 tcx.def_path_str(key.0)
2431 }
2432 }
2433
2434 query is_impossible_associated_item(key: (DefId, DefId)) -> bool {
2435 desc { |tcx|
2436 "checking if `{}` is impossible to reference within `{}`",
2437 tcx.def_path_str(key.1),
2438 tcx.def_path_str(key.0),
2439 }
2440 }
2441
2442 query method_autoderef_steps(
2443 goal: CanonicalTyGoal<'tcx>
2444 ) -> MethodAutoderefStepsResult<'tcx> {
2445 desc { "computing autoderef types for `{}`", goal.canonical.value.value }
2446 }
2447
2448 query rust_target_features(_: CrateNum) -> &'tcx UnordMap<String, rustc_target::target_features::Stability> {
2450 arena_cache
2451 eval_always
2452 desc { "looking up Rust target features" }
2453 }
2454
2455 query implied_target_features(feature: Symbol) -> &'tcx Vec<Symbol> {
2456 arena_cache
2457 eval_always
2458 desc { "looking up implied target features" }
2459 }
2460
2461 query features_query(_: ()) -> &'tcx rustc_feature::Features {
2462 feedable
2463 desc { "looking up enabled feature gates" }
2464 }
2465
2466 query crate_for_resolver((): ()) -> &'tcx Steal<(rustc_ast::Crate, rustc_ast::AttrVec)> {
2467 feedable
2468 no_hash
2469 desc { "the ast before macro expansion and name resolution" }
2470 }
2471
2472 query resolve_instance_raw(
2482 key: ty::PseudoCanonicalInput<'tcx, (DefId, GenericArgsRef<'tcx>)>
2483 ) -> Result<Option<ty::Instance<'tcx>>, ErrorGuaranteed> {
2484 desc { "resolving instance `{}`", ty::Instance::new_raw(key.value.0, key.value.1) }
2485 }
2486
2487 query reveal_opaque_types_in_bounds(key: ty::Clauses<'tcx>) -> ty::Clauses<'tcx> {
2488 desc { "revealing opaque types in `{:?}`", key }
2489 }
2490
2491 query limits(key: ()) -> Limits {
2492 desc { "looking up limits" }
2493 }
2494
2495 query diagnostic_hir_wf_check(
2504 key: (ty::Predicate<'tcx>, WellFormedLoc)
2505 ) -> Option<&'tcx ObligationCause<'tcx>> {
2506 arena_cache
2507 eval_always
2508 no_hash
2509 desc { "performing HIR wf-checking for predicate `{:?}` at item `{:?}`", key.0, key.1 }
2510 }
2511
2512 query global_backend_features(_: ()) -> &'tcx Vec<String> {
2515 arena_cache
2516 eval_always
2517 desc { "computing the backend features for CLI flags" }
2518 }
2519
2520 query check_validity_requirement(key: (ValidityRequirement, ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>)) -> Result<bool, &'tcx ty::layout::LayoutError<'tcx>> {
2521 desc { "checking validity requirement for `{}`: {}", key.1.value, key.0 }
2522 }
2523
2524 query compare_impl_item(key: LocalDefId) -> Result<(), ErrorGuaranteed> {
2529 desc { |tcx| "checking assoc item `{}` is compatible with trait definition", tcx.def_path_str(key) }
2530 return_result_from_ensure_ok
2531 }
2532
2533 query deduced_param_attrs(def_id: DefId) -> &'tcx [ty::DeducedParamAttrs] {
2534 desc { |tcx| "deducing parameter attributes for {}", tcx.def_path_str(def_id) }
2535 separate_provide_extern
2536 }
2537
2538 query doc_link_resolutions(def_id: DefId) -> &'tcx DocLinkResMap {
2539 eval_always
2540 desc { "resolutions for documentation links for a module" }
2541 separate_provide_extern
2542 }
2543
2544 query doc_link_traits_in_scope(def_id: DefId) -> &'tcx [DefId] {
2545 eval_always
2546 desc { "traits in scope for documentation links for a module" }
2547 separate_provide_extern
2548 }
2549
2550 query stripped_cfg_items(cnum: CrateNum) -> &'tcx [StrippedCfgItem] {
2554 desc { "getting cfg-ed out item names" }
2555 separate_provide_extern
2556 }
2557
2558 query generics_require_sized_self(def_id: DefId) -> bool {
2559 desc { "check whether the item has a `where Self: Sized` bound" }
2560 }
2561
2562 query cross_crate_inlinable(def_id: DefId) -> bool {
2563 desc { "whether the item should be made inlinable across crates" }
2564 separate_provide_extern
2565 }
2566
2567 query check_mono_item(key: ty::Instance<'tcx>) {
2571 desc { "monomorphization-time checking" }
2572 }
2573
2574 query skip_move_check_fns(_: ()) -> &'tcx FxIndexSet<DefId> {
2576 arena_cache
2577 desc { "functions to skip for move-size check" }
2578 }
2579
2580 query items_of_instance(key: (ty::Instance<'tcx>, CollectionMode)) -> (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]) {
2581 desc { "collecting items used by `{}`", key.0 }
2582 cache_on_disk_if { true }
2583 }
2584
2585 query size_estimate(key: ty::Instance<'tcx>) -> usize {
2586 desc { "estimating codegen size of `{}`", key }
2587 cache_on_disk_if { true }
2588 }
2589}
2590
2591rustc_with_all_queries! { define_callbacks! }
2592rustc_feedable_queries! { define_feedable! }