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 piece of metadata global to its crate.
  55     GlobalMetaData(D, GlobalMetaDataKind),
  56
  57     // Represents some artifact that we save to disk. Note that these
  58     // do not have a def-id as part of their identifier.
  59     WorkProduct(Arc<WorkProductId>),
  60
  61     // Represents different phases in the compiler.
  62     RegionMaps(D),
  63     Coherence,
  64     Resolve,
  65     CoherenceCheckTrait(D),
  66     CoherenceCheckImpl(D),
  67     CoherenceOverlapCheck(D),
  68     CoherenceOverlapCheckSpecial(D),
  69     Variance,
  70     PrivacyAccessLevels(CrateNum),
  71
  72     // Represents the MIR for a fn; also used as the task node for
  73     // things read/modify that MIR.
  74     MirKrate,
  75     Mir(D),
  76     MirShim(Vec<D>),
  77
  78     BorrowCheckKrate,
  79     BorrowCheck(D),
  80     RvalueCheck(D),
  81     Reachability,
  82     MirKeys,
  83     LateLintCheck,
  84     TransCrateItem(D),
  85     TransWriteMetadata,
  86     CrateVariances,
  87
  88     // Nodes representing bits of computed IR in the tcx. Each shared
  89     // table in the tcx (or elsewhere) maps to one of these
  90     // nodes. Often we map multiple tables to the same node if there
  91     // is no point in distinguishing them (e.g., both the type and
  92     // predicates for an item wind up in `ItemSignature`).
  93     AssociatedItems(D),
  94     ItemSignature(D),
  95     ItemVarianceConstraints(D),
  96     ItemVariances(D),
  97     IsForeignItem(D),
  98     TypeParamPredicates((D, D)),
  99     SizedConstraint(D),
 100     DtorckConstraint(D),
 101     AdtDestructor(D),
 102     AssociatedItemDefIds(D),
 103     InherentImpls(D),
 104     TypeckBodiesKrate,
 105     TypeckTables(D),
 106     UsedTraitImports(D),
 107     ConstEval(D),
 108     SymbolName(D),
 109     SpecializationGraph(D),
 110     ObjectSafety(D),
 111
 112     // The set of impls for a given trait. Ultimately, it would be
 113     // nice to get more fine-grained here (e.g., to include a
 114     // simplified type), but we can't do that until we restructure the
 115     // HIR to distinguish the *header* of an impl from its body.  This
 116     // is because changes to the header may change the self-type of
 117     // the impl and hence would require us to be more conservative
 118     // than changes in the impl body.
 119     TraitImpls(D),
 120
 121     AllLocalTraitImpls,
 122
 123     // Nodes representing caches. To properly handle a true cache, we
 124     // don't use a DepTrackingMap, but rather we push a task node.
 125     // Otherwise the write into the map would be incorrectly
 126     // attributed to the first task that happened to fill the cache,
 127     // which would yield an overly conservative dep-graph.
 128     TraitItems(D),
 129     ReprHints(D),
 130
 131     // Trait selection cache is a little funny. Given a trait
 132     // reference like `Foo: SomeTrait<Bar>`, there could be
 133     // arbitrarily many def-ids to map on in there (e.g., `Foo`,
 134     // `SomeTrait`, `Bar`). We could have a vector of them, but it
 135     // requires heap-allocation, and trait sel in general can be a
 136     // surprisingly hot path. So instead we pick two def-ids: the
 137     // trait def-id, and the first def-id in the input types. If there
 138     // is no def-id in the input types, then we use the trait def-id
 139     // again. So for example:
 140     //
 141     // - `i32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 142     // - `u32: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 143     // - `Clone: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Clone }`
 144     // - `Vec<i32>: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: Vec }`
 145     // - `String: Clone` -> `TraitSelect { trait_def_id: Clone, self_def_id: String }`
 146     // - `Foo: Trait<Bar>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 147     // - `Foo: Trait<i32>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 148     // - `(Foo, Bar): Trait` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 149     // - `i32: Trait<Foo>` -> `TraitSelect { trait_def_id: Trait, self_def_id: Foo }`
 150     //
 151     // You can see that we map many trait refs to the same
 152     // trait-select node.  This is not a problem, it just means
 153     // imprecision in our dep-graph tracking.  The important thing is
 154     // that for any given trait-ref, we always map to the **same**
 155     // trait-select node.
 156     TraitSelect { trait_def_id: D, input_def_id: D },
 157
 158     // For proj. cache, we just keep a list of all def-ids, since it is
 159     // not a hotspot.
 160     ProjectionCache { def_ids: Vec<D> },
 161
 162     DescribeDef(D),
 163     DefSpan(D),
 164     Stability(D),
 165     Deprecation(D),
 166     ItemBodyNestedBodies(D),
 167     ConstIsRvaluePromotableToStatic(D),
 168     ImplParent(D),
 169     TraitOfItem(D),
 170     IsExportedSymbol(D),
 171     IsMirAvailable(D),
 172     ItemAttrs(D),
 173     FnArgNames(D),
 174     FileMap(D, Arc<String>),
 175 }
 176
 177 impl<D: Clone + Debug> DepNode<D> {
 178     /// Used in testing
 179     pub fn from_label_string(label: &str, data: D) -> Result<DepNode<D>, ()> {
 180         macro_rules! check {
 181             ($($name:ident,)*) => {
 182                 match label {
 183                     $(stringify!($name) => Ok(DepNode::$name(data)),)*
 184                     _ => Err(())
 185                 }
 186             }
 187         }
 188
 189         if label == "Krate" {
 190             // special case
 191             return Ok(DepNode::Krate);
 192         }
 193
 194         check! {
 195             BorrowCheck,
 196             Hir,
 197             HirBody,
 198             TransCrateItem,
 199             AssociatedItems,
 200             ItemSignature,
 201             ItemVariances,
 202             IsForeignItem,
 203             AssociatedItemDefIds,
 204             InherentImpls,
 205             TypeckTables,
 206             UsedTraitImports,
 207             TraitImpls,
 208             ReprHints,
 209         }
 210     }
 211
 212     pub fn map_def<E, OP>(&self, mut op: OP) -> Option<DepNode<E>>
 213         where OP: FnMut(&D) -> Option<E>, E: Clone + Debug
 214     {
 215         use self::DepNode::*;
 216
 217         match *self {
 218             Krate => Some(Krate),
 219             BorrowCheckKrate => Some(BorrowCheckKrate),
 220             MirKrate => Some(MirKrate),
 221             TypeckBodiesKrate => Some(TypeckBodiesKrate),
 222             Coherence => Some(Coherence),
 223             CrateVariances => Some(CrateVariances),
 224             Resolve => Some(Resolve),
 225             Variance => Some(Variance),
 226             PrivacyAccessLevels(k) => Some(PrivacyAccessLevels(k)),
 227             Reachability => Some(Reachability),
 228             MirKeys => Some(MirKeys),
 229             LateLintCheck => Some(LateLintCheck),
 230             TransWriteMetadata => Some(TransWriteMetadata),
 231
 232             // work product names do not need to be mapped, because
 233             // they are always absolute.
 234             WorkProduct(ref id) => Some(WorkProduct(id.clone())),
 235
 236             Hir(ref d) => op(d).map(Hir),
 237             HirBody(ref d) => op(d).map(HirBody),
 238             MetaData(ref d) => op(d).map(MetaData),
 239             CoherenceCheckTrait(ref d) => op(d).map(CoherenceCheckTrait),
 240             CoherenceCheckImpl(ref d) => op(d).map(CoherenceCheckImpl),
 241             CoherenceOverlapCheck(ref d) => op(d).map(CoherenceOverlapCheck),
 242             CoherenceOverlapCheckSpecial(ref d) => op(d).map(CoherenceOverlapCheckSpecial),
 243             Mir(ref d) => op(d).map(Mir),
 244             MirShim(ref def_ids) => {
 245                 let def_ids: Option<Vec<E>> = def_ids.iter().map(op).collect();
 246                 def_ids.map(MirShim)
 247             }
 248             BorrowCheck(ref d) => op(d).map(BorrowCheck),
 249             RegionMaps(ref d) => op(d).map(RegionMaps),
 250             RvalueCheck(ref d) => op(d).map(RvalueCheck),
 251             TransCrateItem(ref d) => op(d).map(TransCrateItem),
 252             AssociatedItems(ref d) => op(d).map(AssociatedItems),
 253             ItemSignature(ref d) => op(d).map(ItemSignature),
 254             ItemVariances(ref d) => op(d).map(ItemVariances),
 255             ItemVarianceConstraints(ref d) => op(d).map(ItemVarianceConstraints),
 256             IsForeignItem(ref d) => op(d).map(IsForeignItem),
 257             TypeParamPredicates((ref item, ref param)) => {
 258                 Some(TypeParamPredicates((try_opt!(op(item)), try_opt!(op(param)))))
 259             }
 260             SizedConstraint(ref d) => op(d).map(SizedConstraint),
 261             DtorckConstraint(ref d) => op(d).map(DtorckConstraint),
 262             AdtDestructor(ref d) => op(d).map(AdtDestructor),
 263             AssociatedItemDefIds(ref d) => op(d).map(AssociatedItemDefIds),
 264             InherentImpls(ref d) => op(d).map(InherentImpls),
 265             TypeckTables(ref d) => op(d).map(TypeckTables),
 266             UsedTraitImports(ref d) => op(d).map(UsedTraitImports),
 267             ConstEval(ref d) => op(d).map(ConstEval),
 268             SymbolName(ref d) => op(d).map(SymbolName),
 269             SpecializationGraph(ref d) => op(d).map(SpecializationGraph),
 270             ObjectSafety(ref d) => op(d).map(ObjectSafety),
 271             TraitImpls(ref d) => op(d).map(TraitImpls),
 272             AllLocalTraitImpls => Some(AllLocalTraitImpls),
 273             TraitItems(ref d) => op(d).map(TraitItems),
 274             ReprHints(ref d) => op(d).map(ReprHints),
 275             TraitSelect { ref trait_def_id, ref input_def_id } => {
 276                 op(trait_def_id).and_then(|trait_def_id| {
 277                     op(input_def_id).and_then(|input_def_id| {
 278                         Some(TraitSelect { trait_def_id: trait_def_id,
 279                                            input_def_id: input_def_id })
 280                     })
 281                 })
 282             }
 283             ProjectionCache { ref def_ids } => {
 284                 let def_ids: Option<Vec<E>> = def_ids.iter().map(op).collect();
 285                 def_ids.map(|d| ProjectionCache { def_ids: d })
 286             }
 287             DescribeDef(ref d) => op(d).map(DescribeDef),
 288             DefSpan(ref d) => op(d).map(DefSpan),
 289             Stability(ref d) => op(d).map(Stability),
 290             Deprecation(ref d) => op(d).map(Deprecation),
 291             ItemAttrs(ref d) => op(d).map(ItemAttrs),
 292             FnArgNames(ref d) => op(d).map(FnArgNames),
 293             ImplParent(ref d) => op(d).map(ImplParent),
 294             TraitOfItem(ref d) => op(d).map(TraitOfItem),
 295             IsExportedSymbol(ref d) => op(d).map(IsExportedSymbol),
 296             ItemBodyNestedBodies(ref d) => op(d).map(ItemBodyNestedBodies),
 297             ConstIsRvaluePromotableToStatic(ref d) => op(d).map(ConstIsRvaluePromotableToStatic),
 298             IsMirAvailable(ref d) => op(d).map(IsMirAvailable),
 299             GlobalMetaData(ref d, kind) => op(d).map(|d| GlobalMetaData(d, kind)),
 300             FileMap(ref d, ref file_name) => op(d).map(|d| FileMap(d, file_name.clone())),
 301         }
 302     }
 303 }
 304
 305 /// A "work product" corresponds to a `.o` (or other) file that we
 306 /// save in between runs. These ids do not have a DefId but rather
 307 /// some independent path or string that persists between runs without
 308 /// the need to be mapped or unmapped. (This ensures we can serialize
 309 /// them even in the absence of a tcx.)
 310 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 311 pub struct WorkProductId(pub String);
 312
 313 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 314 pub enum GlobalMetaDataKind {
 315     Krate,
 316     CrateDeps,
 317     DylibDependencyFormats,
 318     LangItems,
 319     LangItemsMissing,
 320     NativeLibraries,
 321     CodeMap,
 322     Impls,
 323     ExportedSymbols,
 324 }