src/librustc/dep_graph/dep_node.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use hir::def_id::CrateNum;
  12 use std::fmt::Debug;
  13 use std::sync::Arc;
  14
  15 macro_rules! try_opt {
  16     ($e:expr) => (
  17         match $e {
  18             Some(r) => r,
  19             None => return None,
  20         }
  21     )
  22 }
  23
  24 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
  25 pub enum DepNode<D: Clone + Debug> {
  26     // The `D` type is "how definitions are identified".
  27     // During compilation, it is always `DefId`, but when serializing
  28     // it is mapped to `DefPath`.
  29
  30     // Represents the `Krate` as a whole (the `hir::Krate` value) (as
  31     // distinct from the krate module). This is basically a hash of
  32     // the entire krate, so if you read from `Krate` (e.g., by calling
  33     // `tcx.hir.krate()`), we will have to assume that any change
  34     // means that you need to be recompiled. This is because the
  35     // `Krate` value gives you access to all other items. To avoid
  36     // this fate, do not call `tcx.hir.krate()`; instead, prefer
  37     // wrappers like `tcx.visit_all_items_in_krate()`.  If there is no
  38     // suitable wrapper, you can use `tcx.dep_graph.ignore()` to gain
  39     // access to the krate, but you must remember to add suitable
  40     // edges yourself for the individual items that you read.
  41     Krate,
  42
  43     // Represents the HIR node with the given node-id
  44     Hir(D),
  45
  46     // Represents the body of a function or method. The def-id is that of the
  47     // function/method.
  48     HirBody(D),
  49
  50     // Represents the metadata for a given HIR node, typically found
  51     // in an extern crate.
  52     MetaData(D),
  53
  54     // Represents some artifact that we save to disk. Note that these
  55     // do not have a def-id as part of their identifier.
  56     WorkProduct(Arc<WorkProductId>),
  57
  58     // Represents different phases in the compiler.
  59     RegionMaps(D),
  60     Coherence,
  61     Resolve,
  62     CoherenceCheckTrait(D),
  63     CoherenceCheckImpl(D),
  64     CoherenceOverlapCheck(D),
  65     CoherenceOverlapCheckSpecial(D),
  66     Variance,
  67     PrivacyAccessLevels(CrateNum),
  68
  69     // Represents the MIR for a fn; also used as the task node for
  70     // things read/modify that MIR.
  71     MirKrate,
  72     Mir(D),
  73     MirShim(Vec<D>),
  74
  75     BorrowCheckKrate,
  76     BorrowCheck(D),
  77     RvalueCheck(D),
  78     Reachability,
  79     MirKeys,
  80     LateLintCheck,
  81     TransCrateItem(D),
  82     TransInlinedItem(D),
  83     TransWriteMetadata,
  84     CrateVariances,
  85
  86     // Nodes representing bits of computed IR in the tcx. Each shared
  87     // table in the tcx (or elsewhere) maps to one of these
  88     // nodes. Often we map multiple tables to the same node if there
  89     // is no point in distinguishing them (e.g., both the type and
  90     // predicates for an item wind up in `ItemSignature`).
  91     AssociatedItems(D),
  92     ItemSignature(D),
  93     ItemVarianceConstraints(D),
  94     ItemVariances(D),
  95     IsForeignItem(D),
  96     TypeParamPredicates((D, D)),
  97     SizedConstraint(D),
  98     DtorckConstraint(D),
  99     AdtDestructor(D),
 100     AssociatedItemDefIds(D),
 101     InherentImpls(D),
 102     TypeckBodiesKrate,
 103     TypeckTables(D),
 104     UsedTraitImports(D),
 105     ConstEval(D),
 106     SymbolName(D),
 107
 108     // The set of impls for a given trait. Ultimately, it would be
 109     // nice to get more fine-grained here (e.g., to include a
 110     // simplified type), but we can't do that until we restructure the
 111     // HIR to distinguish the *header* of an impl from its body.  This
 112     // is because changes to the header may change the self-type of
 113     // the impl and hence would require us to be more conservative
 114     // than changes in the impl body.
 115     TraitImpls(D),
 116
 117     // Nodes representing caches. To properly handle a true cache, we
 118     // don't use a DepTrackingMap, but rather we push a task node.
 119     // Otherwise the write into the map would be incorrectly
 120     // attributed to the first task that happened to fill the cache,
 121     // which would yield an overly conservative dep-graph.
 122     TraitItems(D),
 123     ReprHints(D),
 124
 125     // Trait selection cache is a little funny. Given a trait
 126     // reference like `Foo: SomeTrait<Bar>`, there could be
 127     // arbitrarily many def-ids to map on in there (e.g., `Foo`,
 128     // `SomeTrait`, `Bar`). We could have a vector of them, but it
 129     // requires heap-allocation, and trait sel in general can be a
 130     // surprisingly hot path. So instead we pick two def-ids: the
 131     // trait def-id, and the first def-id in the input types. If there
 132     // is no def-id in the input types, then we use the trait def-id
 133     // again. So for example:
 134     //
 135     // - `i32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 136     // - `u32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 137     // - `Clone: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 138     // - `Vec<i32>: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Vec }`
 139     // - `String: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: String }`
 140     // - `Foo: Trait<Bar>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 141     // - `Foo: Trait<i32>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 142     // - `(Foo, Bar): Trait` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 143     // - `i32: Trait<Foo>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 144     //
 145     // You can see that we map many trait refs to the same
 146     // trait-select node.  This is not a problem, it just means
 147     // imprecision in our dep-graph tracking.  The important thing is
 148     // that for any given trait-ref, we always map to the **same**
 149     // trait-select node.
 150     TraitSelect { trait_def_id: D, input_def_id: D },
 151
 152     // For proj. cache, we just keep a list of all def-ids, since it is
 153     // not a hotspot.
 154     ProjectionCache { def_ids: Vec<D> },
 155
 156     DescribeDef(D),
 157     DefSpan(D),
 158     Stability(D),
 159     Deprecation(D),
 160 }
 161
 162 impl<D: Clone + Debug> DepNode<D> {
 163     /// Used in testing
 164     pub fn from_label_string(label: &str, data: D) -> Result<DepNode<D>, ()> {
 165         macro_rules! check {
 166             ($($name:ident,)*) => {
 167                 match label {
 168                     $(stringify!($name) => Ok(DepNode::$name(data)),)*
 169                     _ => Err(())
 170                 }
 171             }
 172         }
 173
 174         if label == "Krate" {
 175             // special case
 176             return Ok(DepNode::Krate);
 177         }
 178
 179         check! {
 180             BorrowCheck,
 181             Hir,
 182             HirBody,
 183             TransCrateItem,
 184             AssociatedItems,
 185             ItemSignature,
 186             ItemVariances,
 187             IsForeignItem,
 188             AssociatedItemDefIds,
 189             InherentImpls,
 190             TypeckTables,
 191             UsedTraitImports,
 192             TraitImpls,
 193             ReprHints,
 194         }
 195     }
 196
 197     pub fn map_def<E, OP>(&self, mut op: OP) -> Option<DepNode<E>>
 198         where OP: FnMut(&D) -> Option<E>, E: Clone + Debug
 199     {
 200         use self::DepNode::*;
 201
 202         match *self {
 203             Krate => Some(Krate),
 204             BorrowCheckKrate => Some(BorrowCheckKrate),
 205             MirKrate => Some(MirKrate),
 206             TypeckBodiesKrate => Some(TypeckBodiesKrate),
 207             Coherence => Some(Coherence),
 208             CrateVariances => Some(CrateVariances),
 209             Resolve => Some(Resolve),
 210             Variance => Some(Variance),
 211             PrivacyAccessLevels(k) => Some(PrivacyAccessLevels(k)),
 212             Reachability => Some(Reachability),
 213             MirKeys => Some(MirKeys),
 214             LateLintCheck => Some(LateLintCheck),
 215             TransWriteMetadata => Some(TransWriteMetadata),
 216
 217             // work product names do not need to be mapped, because
 218             // they are always absolute.
 219             WorkProduct(ref id) => Some(WorkProduct(id.clone())),
 220
 221             Hir(ref d) => op(d).map(Hir),
 222             HirBody(ref d) => op(d).map(HirBody),
 223             MetaData(ref d) => op(d).map(MetaData),
 224             CoherenceCheckTrait(ref d) => op(d).map(CoherenceCheckTrait),
 225             CoherenceCheckImpl(ref d) => op(d).map(CoherenceCheckImpl),
 226             CoherenceOverlapCheck(ref d) => op(d).map(CoherenceOverlapCheck),
 227             CoherenceOverlapCheckSpecial(ref d) => op(d).map(CoherenceOverlapCheckSpecial),
 228             Mir(ref d) => op(d).map(Mir),
 229             MirShim(ref def_ids) => {
 230                 let def_ids: Option<Vec<E>> = def_ids.iter().map(op).collect();
 231                 def_ids.map(MirShim)
 232             }
 233             BorrowCheck(ref d) => op(d).map(BorrowCheck),
 234             RegionMaps(ref d) => op(d).map(RegionMaps),
 235             RvalueCheck(ref d) => op(d).map(RvalueCheck),
 236             TransCrateItem(ref d) => op(d).map(TransCrateItem),
 237             TransInlinedItem(ref d) => op(d).map(TransInlinedItem),
 238             AssociatedItems(ref d) => op(d).map(AssociatedItems),
 239             ItemSignature(ref d) => op(d).map(ItemSignature),
 240             ItemVariances(ref d) => op(d).map(ItemVariances),
 241             ItemVarianceConstraints(ref d) => op(d).map(ItemVarianceConstraints),
 242             IsForeignItem(ref d) => op(d).map(IsForeignItem),
 243             TypeParamPredicates((ref item, ref param)) => {
 244                 Some(TypeParamPredicates((try_opt!(op(item)), try_opt!(op(param)))))
 245             }
 246             SizedConstraint(ref d) => op(d).map(SizedConstraint),
 247             DtorckConstraint(ref d) => op(d).map(DtorckConstraint),
 248             AdtDestructor(ref d) => op(d).map(AdtDestructor),
 249             AssociatedItemDefIds(ref d) => op(d).map(AssociatedItemDefIds),
 250             InherentImpls(ref d) => op(d).map(InherentImpls),
 251             TypeckTables(ref d) => op(d).map(TypeckTables),
 252             UsedTraitImports(ref d) => op(d).map(UsedTraitImports),
 253             ConstEval(ref d) => op(d).map(ConstEval),
 254             SymbolName(ref d) => op(d).map(SymbolName),
 255             TraitImpls(ref d) => op(d).map(TraitImpls),
 256             TraitItems(ref d) => op(d).map(TraitItems),
 257             ReprHints(ref d) => op(d).map(ReprHints),
 258             TraitSelect { ref trait_def_id, ref input_def_id } => {
 259                 op(trait_def_id).and_then(|trait_def_id| {
 260                     op(input_def_id).and_then(|input_def_id| {
 261                         Some(TraitSelect { trait_def_id: trait_def_id,
 262                                            input_def_id: input_def_id })
 263                     })
 264                 })
 265             }
 266             ProjectionCache { ref def_ids } => {
 267                 let def_ids: Option<Vec<E>> = def_ids.iter().map(op).collect();
 268                 def_ids.map(|d| ProjectionCache { def_ids: d })
 269             }
 270             DescribeDef(ref d) => op(d).map(DescribeDef),
 271             DefSpan(ref d) => op(d).map(DefSpan),
 272             Stability(ref d) => op(d).map(Stability),
 273             Deprecation(ref d) => op(d).map(Deprecation),
 274         }
 275     }
 276 }
 277
 278 /// A "work product" corresponds to a `.o` (or other) file that we
 279 /// save in between runs. These ids do not have a DefId but rather
 280 /// some independent path or string that persists between runs without
 281 /// the need to be mapped or unmapped. (This ensures we can serialize
 282 /// them even in the absence of a tcx.)
 283 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 284 pub struct WorkProductId(pub String);