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     RegionResolveCrate,
  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     LateLintCheck,
  80     TransCrateItem(D),
  81     TransInlinedItem(D),
  82     TransWriteMetadata,
  83
  84     // Nodes representing bits of computed IR in the tcx. Each shared
  85     // table in the tcx (or elsewhere) maps to one of these
  86     // nodes. Often we map multiple tables to the same node if there
  87     // is no point in distinguishing them (e.g., both the type and
  88     // predicates for an item wind up in `ItemSignature`).
  89     AssociatedItems(D),
  90     ItemSignature(D),
  91     IsForeignItem(D),
  92     TypeParamPredicates((D, D)),
  93     SizedConstraint(D),
  94     DtorckConstraint(D),
  95     AdtDestructor(D),
  96     AssociatedItemDefIds(D),
  97     InherentImpls(D),
  98     TypeckBodiesKrate,
  99     TypeckTables(D),
 100     UsedTraitImports(D),
 101     ConstEval(D),
 102     SymbolName(D),
 103
 104     // The set of impls for a given trait. Ultimately, it would be
 105     // nice to get more fine-grained here (e.g., to include a
 106     // simplified type), but we can't do that until we restructure the
 107     // HIR to distinguish the *header* of an impl from its body.  This
 108     // is because changes to the header may change the self-type of
 109     // the impl and hence would require us to be more conservative
 110     // than changes in the impl body.
 111     TraitImpls(D),
 112
 113     // Nodes representing caches. To properly handle a true cache, we
 114     // don't use a DepTrackingMap, but rather we push a task node.
 115     // Otherwise the write into the map would be incorrectly
 116     // attributed to the first task that happened to fill the cache,
 117     // which would yield an overly conservative dep-graph.
 118     TraitItems(D),
 119     ReprHints(D),
 120
 121     // Trait selection cache is a little funny. Given a trait
 122     // reference like `Foo: SomeTrait<Bar>`, there could be
 123     // arbitrarily many def-ids to map on in there (e.g., `Foo`,
 124     // `SomeTrait`, `Bar`). We could have a vector of them, but it
 125     // requires heap-allocation, and trait sel in general can be a
 126     // surprisingly hot path. So instead we pick two def-ids: the
 127     // trait def-id, and the first def-id in the input types. If there
 128     // is no def-id in the input types, then we use the trait def-id
 129     // again. So for example:
 130     //
 131     // - `i32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 132     // - `u32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 133     // - `Clone: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 134     // - `Vec<i32>: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Vec }`
 135     // - `String: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: String }`
 136     // - `Foo: Trait<Bar>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 137     // - `Foo: Trait<i32>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 138     // - `(Foo, Bar): Trait` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 139     // - `i32: Trait<Foo>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 140     //
 141     // You can see that we map many trait refs to the same
 142     // trait-select node.  This is not a problem, it just means
 143     // imprecision in our dep-graph tracking.  The important thing is
 144     // that for any given trait-ref, we always map to the **same**
 145     // trait-select node.
 146     TraitSelect { trait_def_id: D, input_def_id: D },
 147
 148     // For proj. cache, we just keep a list of all def-ids, since it is
 149     // not a hotspot.
 150     ProjectionCache { def_ids: Vec<D> },
 151
 152     // Depnodes for MetaData
 153     DescribeDef(D),
 154     DefSpan(D),
 155 }
 156
 157 impl<D: Clone + Debug> DepNode<D> {
 158     /// Used in testing
 159     pub fn from_label_string(label: &str, data: D) -> Result<DepNode<D>, ()> {
 160         macro_rules! check {
 161             ($($name:ident,)*) => {
 162                 match label {
 163                     $(stringify!($name) => Ok(DepNode::$name(data)),)*
 164                     _ => Err(())
 165                 }
 166             }
 167         }
 168
 169         if label == "Krate" {
 170             // special case
 171             return Ok(DepNode::Krate);
 172         }
 173
 174         check! {
 175             BorrowCheck,
 176             Hir,
 177             HirBody,
 178             TransCrateItem,
 179             AssociatedItems,
 180             ItemSignature,
 181             IsForeignItem,
 182             AssociatedItemDefIds,
 183             InherentImpls,
 184             TypeckTables,
 185             UsedTraitImports,
 186             TraitImpls,
 187             ReprHints,
 188         }
 189     }
 190
 191     pub fn map_def<E, OP>(&self, mut op: OP) -> Option<DepNode<E>>
 192         where OP: FnMut(&D) -> Option<E>, E: Clone + Debug
 193     {
 194         use self::DepNode::*;
 195
 196         match *self {
 197             Krate => Some(Krate),
 198             BorrowCheckKrate => Some(BorrowCheckKrate),
 199             MirKrate => Some(MirKrate),
 200             TypeckBodiesKrate => Some(TypeckBodiesKrate),
 201             RegionResolveCrate => Some(RegionResolveCrate),
 202             Coherence => Some(Coherence),
 203             Resolve => Some(Resolve),
 204             Variance => Some(Variance),
 205             PrivacyAccessLevels(k) => Some(PrivacyAccessLevels(k)),
 206             Reachability => Some(Reachability),
 207             LateLintCheck => Some(LateLintCheck),
 208             TransWriteMetadata => Some(TransWriteMetadata),
 209
 210             // work product names do not need to be mapped, because
 211             // they are always absolute.
 212             WorkProduct(ref id) => Some(WorkProduct(id.clone())),
 213
 214             Hir(ref d) => op(d).map(Hir),
 215             HirBody(ref d) => op(d).map(HirBody),
 216             MetaData(ref d) => op(d).map(MetaData),
 217             CoherenceCheckTrait(ref d) => op(d).map(CoherenceCheckTrait),
 218             CoherenceCheckImpl(ref d) => op(d).map(CoherenceCheckImpl),
 219             CoherenceOverlapCheck(ref d) => op(d).map(CoherenceOverlapCheck),
 220             CoherenceOverlapCheckSpecial(ref d) => op(d).map(CoherenceOverlapCheckSpecial),
 221             Mir(ref d) => op(d).map(Mir),
 222             MirShim(ref def_ids) => {
 223                 let def_ids: Option<Vec<E>> = def_ids.iter().map(op).collect();
 224                 def_ids.map(MirShim)
 225             }
 226             BorrowCheck(ref d) => op(d).map(BorrowCheck),
 227             RvalueCheck(ref d) => op(d).map(RvalueCheck),
 228             TransCrateItem(ref d) => op(d).map(TransCrateItem),
 229             TransInlinedItem(ref d) => op(d).map(TransInlinedItem),
 230             AssociatedItems(ref d) => op(d).map(AssociatedItems),
 231             ItemSignature(ref d) => op(d).map(ItemSignature),
 232             IsForeignItem(ref d) => op(d).map(IsForeignItem),
 233             TypeParamPredicates((ref item, ref param)) => {
 234                 Some(TypeParamPredicates((try_opt!(op(item)), try_opt!(op(param)))))
 235             }
 236             SizedConstraint(ref d) => op(d).map(SizedConstraint),
 237             DtorckConstraint(ref d) => op(d).map(DtorckConstraint),
 238             AdtDestructor(ref d) => op(d).map(AdtDestructor),
 239             AssociatedItemDefIds(ref d) => op(d).map(AssociatedItemDefIds),
 240             InherentImpls(ref d) => op(d).map(InherentImpls),
 241             TypeckTables(ref d) => op(d).map(TypeckTables),
 242             UsedTraitImports(ref d) => op(d).map(UsedTraitImports),
 243             ConstEval(ref d) => op(d).map(ConstEval),
 244             SymbolName(ref d) => op(d).map(SymbolName),
 245             TraitImpls(ref d) => op(d).map(TraitImpls),
 246             TraitItems(ref d) => op(d).map(TraitItems),
 247             ReprHints(ref d) => op(d).map(ReprHints),
 248             TraitSelect { ref trait_def_id, ref input_def_id } => {
 249                 op(trait_def_id).and_then(|trait_def_id| {
 250                     op(input_def_id).and_then(|input_def_id| {
 251                         Some(TraitSelect { trait_def_id: trait_def_id,
 252                                            input_def_id: input_def_id })
 253                     })
 254                 })
 255             }
 256             ProjectionCache { ref def_ids } => {
 257                 let def_ids: Option<Vec<E>> = def_ids.iter().map(op).collect();
 258                 def_ids.map(|d| ProjectionCache { def_ids: d })
 259             }
 260             DescribeDef(ref d) => op(d).map(MetaData),
 261             DefSpan(ref d) => op(d).map(MetaData),
 262         }
 263     }
 264 }
 265
 266 /// A "work product" corresponds to a `.o` (or other) file that we
 267 /// save in between runs. These ids do not have a DefId but rather
 268 /// some independent path or string that persists between runs without
 269 /// the need to be mapped or unmapped. (This ensures we can serialize
 270 /// them even in the absence of a tcx.)
 271 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 272 pub struct WorkProductId(pub String);