1 //! This module defines the `DepNode` type which the compiler uses to represent
2 //! nodes in the dependency graph.
4 //! A `DepNode` consists of a `DepKind` (which
5 //! specifies the kind of thing it represents, like a piece of HIR, MIR, etc)
6 //! and a `Fingerprint`, a 128-bit hash value the exact meaning of which
7 //! depends on the node's `DepKind`. Together, the kind and the fingerprint
8 //! fully identify a dependency node, even across multiple compilation sessions.
9 //! In other words, the value of the fingerprint does not depend on anything
10 //! that is specific to a given compilation session, like an unpredictable
11 //! interning key (e.g., NodeId, DefId, Symbol) or the numeric value of a
12 //! pointer. The concept behind this could be compared to how git commit hashes
13 //! uniquely identify a given commit and has a few advantages:
15 //! * A `DepNode` can simply be serialized to disk and loaded in another session
16 //! without the need to do any "rebasing" (like we have to do for Spans and
17 //! NodeIds) or "retracing" (like we had to do for `DefId` in earlier
18 //! implementations of the dependency graph).
19 //! * A `Fingerprint` is just a bunch of bits, which allows `DepNode` to
20 //! implement `Copy`, `Sync`, `Send`, `Freeze`, etc.
21 //! * Since we just have a bit pattern, `DepNode` can be mapped from disk into
22 //! memory without any post-processing (e.g., "abomination-style" pointer
24 //! * Because a `DepNode` is self-contained, we can instantiate `DepNodes` that
25 //! refer to things that do not exist anymore. In previous implementations
26 //! `DepNode` contained a `DefId`. A `DepNode` referring to something that
27 //! had been removed between the previous and the current compilation session
28 //! could not be instantiated because the current compilation session
29 //! contained no `DefId` for thing that had been removed.
31 //! `DepNode` definition happens in the `define_dep_nodes!()` macro. This macro
32 //! defines the `DepKind` enum and a corresponding `DepConstructor` enum. The
33 //! `DepConstructor` enum links a `DepKind` to the parameters that are needed at
34 //! runtime in order to construct a valid `DepNode` fingerprint.
36 //! Because the macro sees what parameters a given `DepKind` requires, it can
37 //! "infer" some properties for each kind of `DepNode`:
39 //! * Whether a `DepNode` of a given kind has any parameters at all. Some
40 //! `DepNode`s could represent global concepts with only one value.
41 //! * Whether it is possible, in principle, to reconstruct a query key from a
42 //! given `DepNode`. Many `DepKind`s only require a single `DefId` parameter,
43 //! in which case it is possible to map the node's fingerprint back to the
44 //! `DefId` it was computed from. In other cases, too much information gets
45 //! lost during fingerprint computation.
47 //! The `DepConstructor` enum, together with `DepNode::new()`, ensures that only
48 //! valid `DepNode` instances can be constructed. For example, the API does not
49 //! allow for constructing parameterless `DepNode`s with anything other
50 //! than a zeroed out fingerprint. More generally speaking, it relieves the
51 //! user of the `DepNode` API of having to know how to compute the expected
52 //! fingerprint for a given set of node parameters.
54 use crate::mir::interpret::{GlobalId, LitToConstInput};
56 use crate::traits::query::{
57 CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
58 CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
59 CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal,
61 use crate::ty::subst::{GenericArg, SubstsRef};
62 use crate::ty::{self, ParamEnvAnd, Ty, TyCtxt};
64 use rustc_data_structures::fingerprint::Fingerprint;
65 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX};
66 use rustc_hir::definitions::DefPathHash;
68 use rustc_span::symbol::Symbol;
71 pub use rustc_query_system::dep_graph::{DepContext, DepNodeParams};
73 // erase!() just makes tokens go away. It's used to specify which macro argument
74 // is repeated (i.e., which sub-expression of the macro we are in) but don't need
75 // to actually use any of the arguments.
80 macro_rules! is_anon_attr {
89 macro_rules! is_eval_always_attr {
98 macro_rules! contains_anon_attr {
99 ($($attr:ident $(($($attr_args:tt)*))* ),*) => ({$(is_anon_attr!($attr) | )* false});
102 macro_rules! contains_eval_always_attr {
103 ($($attr:ident $(($($attr_args:tt)*))* ),*) => ({$(is_eval_always_attr!($attr) | )* false});
106 macro_rules! define_dep_nodes {
110 $variant:ident $(( $tuple_arg_ty:ty $(,)? ))*
113 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash,
114 RustcEncodable, RustcDecodable)]
115 #[allow(non_camel_case_types)]
121 #[allow(unreachable_code)]
122 pub fn can_reconstruct_query_key<$tcx>(&self) -> bool {
125 DepKind :: $variant => {
126 if contains_anon_attr!($($attrs)*) {
132 return <$tuple_arg_ty as DepNodeParams<TyCtxt<'_>>>
133 ::can_reconstruct_query_key();
142 pub fn is_anon(&self) -> bool {
145 DepKind :: $variant => { contains_anon_attr!($($attrs)*) }
150 pub fn is_eval_always(&self) -> bool {
153 DepKind :: $variant => { contains_eval_always_attr!($($attrs)*) }
158 #[allow(unreachable_code)]
159 pub fn has_params(&self) -> bool {
162 DepKind :: $variant => {
165 erase!($tuple_arg_ty);
176 pub struct DepConstructor;
178 #[allow(non_camel_case_types)]
179 impl DepConstructor {
182 #[allow(unreachable_code, non_snake_case)]
183 pub fn $variant(_tcx: TyCtxt<'_>, $(arg: $tuple_arg_ty)*) -> DepNode {
186 erase!($tuple_arg_ty);
187 return DepNode::construct(_tcx, DepKind::$variant, &arg)
190 return DepNode::construct(_tcx, DepKind::$variant, &())
195 pub type DepNode = rustc_query_system::dep_graph::DepNode<DepKind>;
197 pub trait DepNodeExt: Sized {
198 /// Construct a DepNode from the given DepKind and DefPathHash. This
199 /// method will assert that the given DepKind actually requires a
200 /// single DefId/DefPathHash parameter.
201 fn from_def_path_hash(def_path_hash: DefPathHash, kind: DepKind) -> Self;
203 /// Extracts the DefId corresponding to this DepNode. This will work
204 /// if two conditions are met:
206 /// 1. The Fingerprint of the DepNode actually is a DefPathHash, and
207 /// 2. the item that the DefPath refers to exists in the current tcx.
209 /// Condition (1) is determined by the DepKind variant of the
210 /// DepNode. Condition (2) might not be fulfilled if a DepNode
211 /// refers to something from the previous compilation session that
212 /// has been removed.
213 fn extract_def_id(&self, tcx: TyCtxt<'_>) -> Option<DefId>;
216 fn from_label_string(label: &str, def_path_hash: DefPathHash)
220 fn has_label_string(label: &str) -> bool;
223 impl DepNodeExt for DepNode {
224 /// Construct a DepNode from the given DepKind and DefPathHash. This
225 /// method will assert that the given DepKind actually requires a
226 /// single DefId/DefPathHash parameter.
227 fn from_def_path_hash(def_path_hash: DefPathHash, kind: DepKind) -> DepNode {
228 debug_assert!(kind.can_reconstruct_query_key() && kind.has_params());
231 hash: def_path_hash.0,
235 /// Extracts the DefId corresponding to this DepNode. This will work
236 /// if two conditions are met:
238 /// 1. The Fingerprint of the DepNode actually is a DefPathHash, and
239 /// 2. the item that the DefPath refers to exists in the current tcx.
241 /// Condition (1) is determined by the DepKind variant of the
242 /// DepNode. Condition (2) might not be fulfilled if a DepNode
243 /// refers to something from the previous compilation session that
244 /// has been removed.
245 fn extract_def_id(&self, tcx: TyCtxt<'tcx>) -> Option<DefId> {
246 if self.kind.can_reconstruct_query_key() {
247 let def_path_hash = DefPathHash(self.hash);
248 tcx.def_path_hash_to_def_id.as_ref()?.get(&def_path_hash).cloned()
255 fn from_label_string(label: &str, def_path_hash: DefPathHash) -> Result<DepNode, ()> {
256 let kind = match label {
258 stringify!($variant) => DepKind::$variant,
263 if !kind.can_reconstruct_query_key() {
267 if kind.has_params() {
268 Ok(DepNode::from_def_path_hash(def_path_hash, kind))
270 Ok(DepNode::new_no_params(kind))
275 fn has_label_string(label: &str) -> bool {
278 stringify!($variant) => true,
285 /// Contains variant => str representations for constructing
286 /// DepNode groups for tests.
287 #[allow(dead_code, non_upper_case_globals)]
290 pub const $variant: &str = stringify!($variant);
296 rustc_dep_node_append!([define_dep_nodes!][ <'tcx>
297 // We use this for most things when incr. comp. is turned off.
300 // Represents metadata from an extern crate.
301 [eval_always] CrateMetadata(CrateNum),
305 [] CompileCodegenUnit(Symbol),
308 impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for DefId {
310 fn can_reconstruct_query_key() -> bool {
314 fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
315 tcx.def_path_hash(*self).0
318 fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
319 tcx.def_path_str(*self)
322 fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
323 dep_node.extract_def_id(tcx)
327 impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for LocalDefId {
329 fn can_reconstruct_query_key() -> bool {
333 fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
334 self.to_def_id().to_fingerprint(tcx)
337 fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
338 self.to_def_id().to_debug_str(tcx)
341 fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
342 dep_node.extract_def_id(tcx).map(|id| id.expect_local())
346 impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for CrateNum {
348 fn can_reconstruct_query_key() -> bool {
352 fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
353 let def_id = DefId { krate: *self, index: CRATE_DEF_INDEX };
354 tcx.def_path_hash(def_id).0
357 fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
358 tcx.crate_name(*self).to_string()
361 fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
362 dep_node.extract_def_id(tcx).map(|id| id.krate)
366 impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for (DefId, DefId) {
368 fn can_reconstruct_query_key() -> bool {
372 // We actually would not need to specialize the implementation of this
373 // method but it's faster to combine the hashes than to instantiate a full
374 // hashing context and stable-hashing state.
375 fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
376 let (def_id_0, def_id_1) = *self;
378 let def_path_hash_0 = tcx.def_path_hash(def_id_0);
379 let def_path_hash_1 = tcx.def_path_hash(def_id_1);
381 def_path_hash_0.0.combine(def_path_hash_1.0)
384 fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
385 let (def_id_0, def_id_1) = *self;
387 format!("({}, {})", tcx.def_path_debug_str(def_id_0), tcx.def_path_debug_str(def_id_1))
391 impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for HirId {
393 fn can_reconstruct_query_key() -> bool {
397 // We actually would not need to specialize the implementation of this
398 // method but it's faster to combine the hashes than to instantiate a full
399 // hashing context and stable-hashing state.
400 fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
401 let HirId { owner, local_id } = *self;
403 let def_path_hash = tcx.def_path_hash(owner.to_def_id());
404 let local_id = Fingerprint::from_smaller_hash(local_id.as_u32().into());
406 def_path_hash.0.combine(local_id)