2 use crate::infer::canonical::{self, Canonical};
3 use crate::lint::LintLevelMap;
4 use crate::metadata::ModChild;
5 use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
6 use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportLevel};
7 use crate::middle::lib_features::LibFeatures;
8 use crate::middle::privacy::AccessLevels;
9 use crate::middle::region;
10 use crate::middle::resolve_lifetime::{
11 LifetimeScopeForPath, ObjectLifetimeDefault, Region, ResolveLifetimes,
13 use crate::middle::stability::{self, DeprecationEntry};
15 use crate::mir::interpret::GlobalId;
16 use crate::mir::interpret::{ConstAlloc, LitToConstError, LitToConstInput};
17 use crate::mir::interpret::{ConstValue, EvalToAllocationRawResult, EvalToConstValueResult};
18 use crate::mir::mono::CodegenUnit;
20 use crate::traits::query::{
21 CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
22 CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
23 CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal, NoSolution,
25 use crate::traits::query::{
26 DropckOutlivesResult, DtorckConstraint, MethodAutoderefStepsResult, NormalizationResult,
29 use crate::traits::specialization_graph;
30 use crate::traits::{self, ImplSource};
31 use crate::ty::fast_reject::SimplifiedType;
32 use crate::ty::subst::{GenericArg, SubstsRef};
33 use crate::ty::util::AlwaysRequiresDrop;
34 use crate::ty::{self, AdtSizedConstraint, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt};
35 use rustc_ast::expand::allocator::AllocatorKind;
36 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
37 use rustc_data_structures::steal::Steal;
38 use rustc_data_structures::svh::Svh;
39 use rustc_data_structures::sync::Lrc;
40 use rustc_errors::ErrorReported;
42 use rustc_hir::def::DefKind;
43 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LocalDefId};
44 use rustc_hir::lang_items::{LangItem, LanguageItems};
45 use rustc_hir::{Crate, ItemLocalId, TraitCandidate};
46 use rustc_index::{bit_set::FiniteBitSet, vec::IndexVec};
47 use rustc_session::config::{EntryFnType, OptLevel, OutputFilenames, SymbolManglingVersion};
48 use rustc_session::cstore::{CrateDepKind, CrateSource};
49 use rustc_session::cstore::{ExternCrate, ForeignModule, LinkagePreference, NativeLib};
50 use rustc_session::utils::NativeLibKind;
51 use rustc_session::Limits;
52 use rustc_target::abi;
53 use rustc_target::spec::PanicStrategy;
56 use rustc_attr as attr;
57 use rustc_span::symbol::Symbol;
58 use rustc_span::{Span, DUMMY_SP};
59 use std::collections::BTreeMap;
61 use std::path::PathBuf;
64 pub(crate) use rustc_query_system::query::QueryJobId;
65 use rustc_query_system::query::*;
67 #[derive(Copy, Clone)]
68 pub struct TyCtxtAt<'tcx> {
69 pub tcx: TyCtxt<'tcx>,
73 impl<'tcx> Deref for TyCtxtAt<'tcx> {
74 type Target = TyCtxt<'tcx>;
76 fn deref(&self) -> &Self::Target {
81 #[derive(Copy, Clone)]
82 pub struct TyCtxtEnsure<'tcx> {
83 pub tcx: TyCtxt<'tcx>,
86 impl<'tcx> TyCtxt<'tcx> {
87 /// Returns a transparent wrapper for `TyCtxt`, which ensures queries
88 /// are executed instead of just returning their results.
90 pub fn ensure(self) -> TyCtxtEnsure<'tcx> {
91 TyCtxtEnsure { tcx: self }
94 /// Returns a transparent wrapper for `TyCtxt` which uses
95 /// `span` as the location of queries performed through it.
97 pub fn at(self, span: Span) -> TyCtxtAt<'tcx> {
98 TyCtxtAt { tcx: self, span }
101 pub fn try_mark_green(self, dep_node: &dep_graph::DepNode) -> bool {
102 self.queries.try_mark_green(self, dep_node)
106 /// Helper for `TyCtxtEnsure` to avoid a closure.
110 macro_rules! query_helper_param_ty {
111 (DefId) => { impl IntoQueryParam<DefId> };
115 macro_rules! query_storage {
116 ([][$K:ty, $V:ty]) => {
117 <DefaultCacheSelector as CacheSelector<$K, $V>>::Cache
119 ([(storage $ty:ty) $($rest:tt)*][$K:ty, $V:ty]) => {
120 <$ty as CacheSelector<$K, $V>>::Cache
122 ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
123 query_storage!([$($modifiers)*][$($args)*])
127 macro_rules! separate_provide_extern_decl {
128 ([][$name:ident]) => {
131 ([(separate_provide_extern) $($rest:tt)*][$name:ident]) => {
134 query_keys::$name<'tcx>,
135 ) -> query_values::$name<'tcx>
137 ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
138 separate_provide_extern_decl!([$($modifiers)*][$($args)*])
142 macro_rules! separate_provide_extern_default {
143 ([][$name:ident]) => {
146 ([(separate_provide_extern) $($rest:tt)*][$name:ident]) => {
148 "`tcx.{}({:?})` unsupported by its crate; \
149 perhaps the `{}` query was never assigned a provider function",
155 ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
156 separate_provide_extern_default!([$($modifiers)*][$($args)*])
160 macro_rules! opt_remap_env_constness {
161 ([][$name:ident]) => {};
162 ([(remap_env_constness) $($rest:tt)*][$name:ident]) => {
163 let $name = $name.without_const();
165 ([$other:tt $($modifiers:tt)*][$name:ident]) => {
166 opt_remap_env_constness!([$($modifiers)*][$name])
170 macro_rules! define_callbacks {
173 [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty,)*) => {
175 // HACK(eddyb) this is like the `impl QueryConfig for queries::$name`
176 // below, but using type aliases instead of associated types, to bypass
177 // the limitations around normalizing under HRTB - for example, this:
178 // `for<'tcx> fn(...) -> <queries::$name<'tcx> as QueryConfig<TyCtxt<'tcx>>>::Value`
179 // doesn't currently normalize to `for<'tcx> fn(...) -> query_values::$name<'tcx>`.
180 // This is primarily used by the `provide!` macro in `rustc_metadata`.
181 #[allow(nonstandard_style, unused_lifetimes)]
185 $(pub type $name<$tcx> = $($K)*;)*
187 #[allow(nonstandard_style, unused_lifetimes)]
188 pub mod query_values {
191 $(pub type $name<$tcx> = $V;)*
193 #[allow(nonstandard_style, unused_lifetimes)]
194 pub mod query_storage {
197 $(pub type $name<$tcx> = query_storage!([$($modifiers)*][$($K)*, $V]);)*
199 #[allow(nonstandard_style, unused_lifetimes)]
200 pub mod query_stored {
203 $(pub type $name<$tcx> = <query_storage::$name<$tcx> as QueryStorage>::Stored;)*
207 pub struct QueryCaches<$tcx> {
208 $($(#[$attr])* pub $name: QueryCacheStore<query_storage::$name<$tcx>>,)*
211 impl<$tcx> TyCtxtEnsure<$tcx> {
214 pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
215 let key = key.into_query_param();
216 opt_remap_env_constness!([$($modifiers)*][key]);
218 let cached = try_get_cached(self.tcx, &self.tcx.query_caches.$name, &key, noop);
220 let lookup = match cached {
222 Err(lookup) => lookup,
225 self.tcx.queries.$name(self.tcx, DUMMY_SP, key, lookup, QueryMode::Ensure);
229 impl<$tcx> TyCtxt<$tcx> {
233 pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> query_stored::$name<$tcx>
235 self.at(DUMMY_SP).$name(key)
239 impl<$tcx> TyCtxtAt<$tcx> {
242 pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> query_stored::$name<$tcx>
244 let key = key.into_query_param();
245 opt_remap_env_constness!([$($modifiers)*][key]);
247 let cached = try_get_cached(self.tcx, &self.tcx.query_caches.$name, &key, Clone::clone);
249 let lookup = match cached {
250 Ok(value) => return value,
251 Err(lookup) => lookup,
254 self.tcx.queries.$name(self.tcx, self.span, key, lookup, QueryMode::Get).unwrap()
258 pub struct Providers {
259 $(pub $name: for<'tcx> fn(
261 query_keys::$name<'tcx>,
262 ) -> query_values::$name<'tcx>,)*
265 pub struct ExternProviders {
266 $(pub $name: separate_provide_extern_decl!([$($modifiers)*][$name]),)*
269 impl Default for Providers {
270 fn default() -> Self {
272 $($name: |_, key| bug!(
273 "`tcx.{}({:?})` unsupported by its crate; \
274 perhaps the `{}` query was never assigned a provider function",
283 impl Default for ExternProviders {
284 fn default() -> Self {
286 $($name: separate_provide_extern_default!([$($modifiers)*][$name]),)*
291 impl Copy for Providers {}
292 impl Clone for Providers {
293 fn clone(&self) -> Self { *self }
296 impl Copy for ExternProviders {}
297 impl Clone for ExternProviders {
298 fn clone(&self) -> Self { *self }
301 pub trait QueryEngine<'tcx>: rustc_data_structures::sync::Sync {
302 fn as_any(&'tcx self) -> &'tcx dyn std::any::Any;
304 fn try_mark_green(&'tcx self, tcx: TyCtxt<'tcx>, dep_node: &dep_graph::DepNode) -> bool;
311 key: query_keys::$name<$tcx>,
314 ) -> Option<query_stored::$name<$tcx>>;)*
319 // Each of these queries corresponds to a function pointer field in the
320 // `Providers` struct for requesting a value of that type, and a method
321 // on `tcx: TyCtxt` (and `tcx.at(span)`) for doing that request in a way
322 // which memoizes and does dep-graph tracking, wrapping around the actual
323 // `Providers` that the driver creates (using several `rustc_*` crates).
325 // The result type of each query must implement `Clone`, and additionally
326 // `ty::query::values::Value`, which produces an appropriate placeholder
327 // (error) value if the query resulted in a query cycle.
328 // Queries marked with `fatal_cycle` do not need the latter implementation,
329 // as they will raise an fatal error on query cycles instead.
331 rustc_query_append! { [define_callbacks!][<'tcx>] }
334 use super::{DefId, LocalDefId};
336 /// An analogue of the `Into` trait that's intended only for query paramaters.
338 /// This exists to allow queries to accept either `DefId` or `LocalDefId` while requiring that the
339 /// user call `to_def_id` to convert between them everywhere else.
340 pub trait IntoQueryParam<P> {
341 fn into_query_param(self) -> P;
344 impl<P> IntoQueryParam<P> for P {
346 fn into_query_param(self) -> P {
351 impl IntoQueryParam<DefId> for LocalDefId {
353 fn into_query_param(self) -> DefId {
359 use sealed::IntoQueryParam;
361 impl<'tcx> TyCtxt<'tcx> {
362 pub fn def_kind(self, def_id: impl IntoQueryParam<DefId>) -> DefKind {
363 let def_id = def_id.into_query_param();
364 self.opt_def_kind(def_id)
365 .unwrap_or_else(|| bug!("def_kind: unsupported node: {:?}", def_id))
369 impl<'tcx> TyCtxtAt<'tcx> {
370 pub fn def_kind(self, def_id: impl IntoQueryParam<DefId>) -> DefKind {
371 let def_id = def_id.into_query_param();
372 self.opt_def_kind(def_id)
373 .unwrap_or_else(|| bug!("def_kind: unsupported node: {:?}", def_id))