diff options
Diffstat (limited to 'compiler/rustc_middle/src/query/mod.rs')
| -rw-r--r-- | compiler/rustc_middle/src/query/mod.rs | 141 |
1 files changed, 85 insertions, 56 deletions
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs index 06041bbb02d..54391bd649e 100644 --- a/compiler/rustc_middle/src/query/mod.rs +++ b/compiler/rustc_middle/src/query/mod.rs @@ -110,10 +110,6 @@ rustc_queries! { separate_provide_extern } - query default_anon_const_substs(key: DefId) -> SubstsRef<'tcx> { - desc { |tcx| "computing the default generic arguments for `{}`", tcx.def_path_str(key) } - } - /// Records the type of every item. query type_of(key: DefId) -> Ty<'tcx> { desc { |tcx| @@ -256,7 +252,7 @@ rustc_queries! { /// Set of all the `DefId`s in this crate that have MIR associated with /// them. This includes all the body owners, but also things like struct /// constructors. - query mir_keys(_: ()) -> FxHashSet<LocalDefId> { + query mir_keys(_: ()) -> rustc_data_structures::fx::FxIndexSet<LocalDefId> { storage(ArenaCacheSelector<'tcx>) desc { "getting a list of all mir_keys" } } @@ -386,16 +382,6 @@ rustc_queries! { storage(ArenaCacheSelector<'tcx>) } - /// Returns the name of the file that contains the function body, if instrumented for coverage. - query covered_file_name(key: DefId) -> Option<Symbol> { - desc { - |tcx| "retrieving the covered file name, if instrumented, for `{}`", - tcx.def_path_str(key) - } - storage(ArenaCacheSelector<'tcx>) - cache_on_disk_if { key.is_local() } - } - /// Returns the `CodeRegions` for a function that has instrumented coverage, in case the /// function was optimized out before codegen, and before being added to the Coverage Map. query covered_code_regions(key: DefId) -> Vec<&'tcx mir::coverage::CodeRegion> { @@ -522,6 +508,7 @@ rustc_queries! { } query adt_def(key: DefId) -> &'tcx ty::AdtDef { desc { |tcx| "computing ADT definition for `{}`", tcx.def_path_str(key) } + cache_on_disk_if { key.is_local() } separate_provide_extern } query adt_destructor(key: DefId) -> Option<ty::Destructor> { @@ -629,6 +616,32 @@ rustc_queries! { desc { |tcx| "collecting associated items of {}", tcx.def_path_str(key) } } + /// Maps from associated items on a trait to the corresponding associated + /// item on the impl specified by `impl_id`. + /// + /// For example, with the following code + /// + /// ``` + /// struct Type {} + /// // DefId + /// trait Trait { // trait_id + /// fn f(); // trait_f + /// fn g() {} // trait_g + /// } + /// + /// impl Trait for Type { // impl_id + /// fn f() {} // impl_f + /// fn g() {} // impl_g + /// } + /// ``` + /// + /// The map returned for `tcx.impl_item_implementor_ids(impl_id)` would be + ///`{ trait_f: impl_f, trait_g: impl_g }` + query impl_item_implementor_ids(impl_id: DefId) -> FxHashMap<DefId, DefId> { + desc { |tcx| "comparing impl items against trait for {}", tcx.def_path_str(impl_id) } + storage(ArenaCacheSelector<'tcx>) + } + /// Given an `impl_id`, return the trait it implements. /// Return `None` if this is an inherent impl. query impl_trait_ref(impl_id: DefId) -> Option<ty::TraitRef<'tcx>> { @@ -649,7 +662,6 @@ rustc_queries! { /// Methods in these implementations don't need to be exported. query inherent_impls(key: DefId) -> &'tcx [DefId] { desc { |tcx| "collecting inherent impls for `{}`", tcx.def_path_str(key) } - eval_always separate_provide_extern } @@ -797,7 +809,7 @@ rustc_queries! { /// additional requirements that the closure's creator must verify. query mir_borrowck(key: LocalDefId) -> &'tcx mir::BorrowCheckResult<'tcx> { desc { |tcx| "borrow-checking `{}`", tcx.def_path_str(key.to_def_id()) } - cache_on_disk_if(tcx) { tcx.is_closure(key.to_def_id()) } + cache_on_disk_if(tcx) { tcx.is_typeck_child(key.to_def_id()) } } query mir_borrowck_const_arg(key: (LocalDefId, DefId)) -> &'tcx mir::BorrowCheckResult<'tcx> { desc { @@ -810,18 +822,23 @@ rustc_queries! { /// Not meant to be used directly outside of coherence. query crate_inherent_impls(k: ()) -> CrateInherentImpls { storage(ArenaCacheSelector<'tcx>) - eval_always desc { "all inherent impls defined in crate" } } /// Checks all types in the crate for overlap in their inherent impls. Reports errors. /// Not meant to be used directly outside of coherence. - query crate_inherent_impls_overlap_check(_: ()) - -> () { - eval_always + query crate_inherent_impls_overlap_check(_: ()) -> () { desc { "check for overlap between inherent impls defined in this crate" } } + /// Checks whether all impls in the crate pass the overlap check, returning + /// which impls fail it. If all impls are correct, the returned slice is empty. + query orphan_check_crate(_: ()) -> &'tcx [LocalDefId] { + desc { + "checking whether the immpl in the this crate follow the orphan rules", + } + } + /// Check whether the function has any recursion that could cause the inliner to trigger /// a cycle. Returns the call stack causing the cycle. The call stack does not contain the /// current function, just all intermediate functions. @@ -876,6 +893,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, ConstAlloc<'tcx>> ) -> Option<ty::ValTree<'tcx>> { desc { "destructure constant" } + remap_env_constness } /// Destructure a constant ADT or array into its variant index and its @@ -884,6 +902,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, &'tcx ty::Const<'tcx>> ) -> mir::DestructuredConst<'tcx> { desc { "destructure constant" } + remap_env_constness } /// Dereference a constant reference or raw pointer and turn the result into a constant @@ -892,6 +911,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, &'tcx ty::Const<'tcx>> ) -> &'tcx ty::Const<'tcx> { desc { "deref constant" } + remap_env_constness } query const_caller_location(key: (rustc_span::Symbol, u32, u32)) -> ConstValue<'tcx> { @@ -1056,11 +1076,6 @@ rustc_queries! { } /// Return all `impl` blocks in the current crate. - /// - /// To allow caching this between crates, you must pass in [`LOCAL_CRATE`] as the crate number. - /// Passing in any other crate will cause an ICE. - /// - /// [`LOCAL_CRATE`]: rustc_hir::def_id::LOCAL_CRATE query all_local_trait_impls(_: ()) -> &'tcx BTreeMap<DefId, Vec<LocalDefId>> { desc { "local trait impls" } } @@ -1101,26 +1116,32 @@ rustc_queries! { /// `ty.is_copy()`, etc, since that will prune the environment where possible. query is_copy_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { desc { "computing whether `{}` is `Copy`", env.value } + remap_env_constness } /// Query backing `TyS::is_sized`. query is_sized_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { desc { "computing whether `{}` is `Sized`", env.value } + remap_env_constness } /// Query backing `TyS::is_freeze`. query is_freeze_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { desc { "computing whether `{}` is freeze", env.value } + remap_env_constness } /// Query backing `TyS::is_unpin`. query is_unpin_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { desc { "computing whether `{}` is `Unpin`", env.value } + remap_env_constness } /// Query backing `TyS::needs_drop`. query needs_drop_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { desc { "computing whether `{}` needs drop", env.value } + remap_env_constness } /// Query backing `TyS::has_significant_drop_raw`. query has_significant_drop_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { desc { "computing whether `{}` has a significant drop", env.value } + remap_env_constness } /// Query backing `TyS::is_structural_eq_shallow`. @@ -1159,6 +1180,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, Ty<'tcx>> ) -> Result<ty::layout::TyAndLayout<'tcx>, ty::layout::LayoutError<'tcx>> { desc { "computing layout of `{}`", key.value } + remap_env_constness } /// Compute a `FnAbi` suitable for indirect calls, i.e. to `fn` pointers. @@ -1169,6 +1191,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, (ty::PolyFnSig<'tcx>, &'tcx ty::List<Ty<'tcx>>)> ) -> Result<&'tcx abi::call::FnAbi<'tcx, Ty<'tcx>>, ty::layout::FnAbiError<'tcx>> { desc { "computing call ABI of `{}` function pointers", key.value.0 } + remap_env_constness } /// Compute a `FnAbi` suitable for declaring/defining an `fn` instance, and for @@ -1180,6 +1203,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>)> ) -> Result<&'tcx abi::call::FnAbi<'tcx, Ty<'tcx>>, ty::layout::FnAbiError<'tcx>> { desc { "computing call ABI of `{}`", key.value.0 } + remap_env_constness } query dylib_dependency_formats(_: CrateNum) @@ -1249,8 +1273,8 @@ rustc_queries! { desc { "traits in scope at a block" } } - query module_exports(def_id: LocalDefId) -> Option<&'tcx [Export]> { - desc { |tcx| "looking up items exported by `{}`", tcx.def_path_str(def_id.to_def_id()) } + query module_reexports(def_id: LocalDefId) -> Option<&'tcx [ModChild]> { + desc { |tcx| "looking up reexports of module `{}`", tcx.def_path_str(def_id.to_def_id()) } } query impl_defaultness(def_id: DefId) -> hir::Defaultness { @@ -1386,20 +1410,11 @@ rustc_queries! { /// Given a crate and a trait, look up all impls of that trait in the crate. /// Return `(impl_id, self_ty)`. - query implementations_of_trait(_: (CrateNum, DefId)) - -> &'tcx [(DefId, Option<ty::fast_reject::SimplifiedType>)] { + query implementations_of_trait(_: (CrateNum, DefId)) -> &'tcx [(DefId, Option<SimplifiedType>)] { desc { "looking up implementations of a trait in a crate" } separate_provide_extern } - /// Given a crate, look up all trait impls in that crate. - /// Return `(impl_id, self_ty)`. - query all_trait_implementations(_: CrateNum) - -> &'tcx [(DefId, Option<ty::fast_reject::SimplifiedType>)] { - desc { "looking up all (?) trait implementations" } - separate_provide_extern - } - query is_dllimport_foreign_item(def_id: DefId) -> bool { desc { |tcx| "is_dllimport_foreign_item({})", tcx.def_path_str(def_id) } } @@ -1464,6 +1479,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, Ty<'tcx>> ) -> ty::inhabitedness::DefIdForest { desc { "computing the inhabitedness of `{:?}`", key } + remap_env_constness } query dep_kind(_: CrateNum) -> CrateDepKind { @@ -1478,17 +1494,16 @@ rustc_queries! { desc { "fetching what a crate is named" } separate_provide_extern } - query item_children(def_id: DefId) -> &'tcx [Export] { - desc { |tcx| "collecting child items of `{}`", tcx.def_path_str(def_id) } + query module_children(def_id: DefId) -> &'tcx [ModChild] { + desc { |tcx| "collecting child items of module `{}`", tcx.def_path_str(def_id) } separate_provide_extern } query extern_mod_stmt_cnum(def_id: LocalDefId) -> Option<CrateNum> { desc { |tcx| "computing crate imported by `{}`", tcx.def_path_str(def_id.to_def_id()) } } - query get_lib_features(_: ()) -> LibFeatures { + query lib_features(_: ()) -> LibFeatures { storage(ArenaCacheSelector<'tcx>) - eval_always desc { "calculating the lib features map" } } query defined_lib_features(_: CrateNum) @@ -1527,8 +1542,7 @@ rustc_queries! { desc { "calculating the missing lang items in a crate" } separate_provide_extern } - query visible_parent_map(_: ()) -> DefIdMap<DefId> { - storage(ArenaCacheSelector<'tcx>) + query visible_parent_map(_: ()) -> Lrc<DefIdMap<DefId>> { desc { "calculating the visible parent map" } } query trimmed_def_paths(_: ()) -> FxHashMap<DefId, Symbol> { @@ -1563,7 +1577,6 @@ rustc_queries! { query upvars_mentioned(def_id: DefId) -> Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>> { desc { |tcx| "collecting upvars mentioned in `{}`", tcx.def_path_str(def_id) } - eval_always } query maybe_unused_trait_import(def_id: LocalDefId) -> bool { desc { |tcx| "maybe_unused_trait_import for `{}`", tcx.def_path_str(def_id.to_def_id()) } @@ -1585,11 +1598,11 @@ rustc_queries! { desc { "fetching all foreign CrateNum instances" } } - /// A vector of every trait accessible in the whole crate - /// (i.e., including those from subcrates). This is used only for - /// error reporting. - query all_traits(_: ()) -> &'tcx [DefId] { - desc { "fetching all foreign and local traits" } + /// A list of all traits in a crate, used by rustdoc and error reporting. + /// NOTE: Not named just `traits` due to a naming conflict. + query traits_in_crate(_: CrateNum) -> &'tcx [DefId] { + desc { "fetching all traits in a crate" } + separate_provide_extern } /// The list of symbols exported from the given crate. @@ -1645,20 +1658,23 @@ rustc_queries! { NoSolution, > { desc { "normalizing `{:?}`", goal } + remap_env_constness } - /// Do not call this query directly: invoke `normalize_erasing_regions` instead. - query normalize_generic_arg_after_erasing_regions( + /// Do not call this query directly: invoke `try_normalize_erasing_regions` instead. + query try_normalize_generic_arg_after_erasing_regions( goal: ParamEnvAnd<'tcx, GenericArg<'tcx>> - ) -> GenericArg<'tcx> { + ) -> Result<GenericArg<'tcx>, NoSolution> { desc { "normalizing `{}`", goal.value } + remap_env_constness } - /// Do not call this query directly: invoke `normalize_erasing_regions` instead. - query normalize_mir_const_after_erasing_regions( + /// Do not call this query directly: invoke `try_normalize_erasing_regions` instead. + query try_normalize_mir_const_after_erasing_regions( goal: ParamEnvAnd<'tcx, mir::ConstantKind<'tcx>> - ) -> mir::ConstantKind<'tcx> { + ) -> Result<mir::ConstantKind<'tcx>, NoSolution> { desc { "normalizing `{}`", goal.value } + remap_env_constness } query implied_outlives_bounds( @@ -1668,6 +1684,7 @@ rustc_queries! { NoSolution, > { desc { "computing implied outlives bounds for `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: invoke `infcx.at().dropck_outlives()` instead. @@ -1678,6 +1695,7 @@ rustc_queries! { NoSolution, > { desc { "computing dropck types for `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: invoke `infcx.predicate_may_hold()` or @@ -1705,6 +1723,7 @@ rustc_queries! { NoSolution, > { desc { "evaluating `type_op_ascribe_user_type` `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: part of the `Eq` type-op @@ -1715,6 +1734,7 @@ rustc_queries! { NoSolution, > { desc { "evaluating `type_op_eq` `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: part of the `Subtype` type-op @@ -1725,6 +1745,7 @@ rustc_queries! { NoSolution, > { desc { "evaluating `type_op_subtype` `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: part of the `ProvePredicate` type-op @@ -1745,6 +1766,7 @@ rustc_queries! { NoSolution, > { desc { "normalizing `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: part of the `Normalize` type-op @@ -1755,6 +1777,7 @@ rustc_queries! { NoSolution, > { desc { "normalizing `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: part of the `Normalize` type-op @@ -1765,6 +1788,7 @@ rustc_queries! { NoSolution, > { desc { "normalizing `{:?}`", goal } + remap_env_constness } /// Do not call this query directly: part of the `Normalize` type-op @@ -1775,6 +1799,7 @@ rustc_queries! { NoSolution, > { desc { "normalizing `{:?}`", goal } + remap_env_constness } query subst_and_check_impossible_predicates(key: (DefId, SubstsRef<'tcx>)) -> bool { @@ -1788,6 +1813,7 @@ rustc_queries! { goal: CanonicalTyGoal<'tcx> ) -> MethodAutoderefStepsResult<'tcx> { desc { "computing autoderef types for `{:?}`", goal } + remap_env_constness } query supported_target_features(_: CrateNum) -> FxHashMap<String, Option<Symbol>> { @@ -1820,6 +1846,7 @@ rustc_queries! { key: ty::ParamEnvAnd<'tcx, (DefId, SubstsRef<'tcx>)> ) -> Result<Option<ty::Instance<'tcx>>, ErrorReported> { desc { "resolving instance `{}`", ty::Instance::new(key.value.0, key.value.1) } + remap_env_constness } query resolve_instance_of_const_arg( @@ -1829,6 +1856,7 @@ rustc_queries! { "resolving instance of the const argument `{}`", ty::Instance::new(key.value.0.to_def_id(), key.value.2), } + remap_env_constness } query normalize_opaque_types(key: &'tcx ty::List<ty::Predicate<'tcx>>) -> &'tcx ty::List<ty::Predicate<'tcx>> { @@ -1843,6 +1871,7 @@ rustc_queries! { /// size, to account for partial initialisation. See #49298 for details.) query conservative_is_privately_uninhabited(key: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { desc { "conservatively checking if {:?} is privately uninhabited", key } + remap_env_constness } query limits(key: ()) -> Limits { |