merge TypeckItemBody and Tables depnodes

Author: nikomatsakis

src/librustc/dep_graph/README.md

@@ -326,15 +326,15 @@ The idea is that you can annotate a test like:
 #[rustc_if_this_changed]
 fn foo() { }
 
-#[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+#[rustc_then_this_would_need(Tables)] //~ ERROR OK
 fn bar() { foo(); }
 
-#[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR no path
+#[rustc_then_this_would_need(Tables)] //~ ERROR no path
 fn baz() { }
 ```
 
 This will check whether there is a path in the dependency graph from
-`Hir(foo)` to `TypeckItemBody(bar)`. An error is reported for each
+`Hir(foo)` to `Tables(bar)`. An error is reported for each
 `#[rustc_then_this_would_need]` annotation that indicates whether a
 path exists. `//~ ERROR` annotations can then be used to test if a
 path is found (as demonstrated above).
@@ -371,27 +371,27 @@ A node is considered to match a filter if all of those strings appear in its
 label. So, for example:
 
 ```
-RUST_DEP_GRAPH_FILTER='-> TypeckItemBody'
+RUST_DEP_GRAPH_FILTER='-> Tables'
 ```
 
-would select the predecessors of all `TypeckItemBody` nodes. Usually though you
-want the `TypeckItemBody` node for some particular fn, so you might write:
+would select the predecessors of all `Tables` nodes. Usually though you
+want the `Tables` node for some particular fn, so you might write:
 
 ```
-RUST_DEP_GRAPH_FILTER='-> TypeckItemBody & bar'
+RUST_DEP_GRAPH_FILTER='-> Tables & bar'
 ```
 
-This will select only the `TypeckItemBody` nodes for fns with `bar` in their name.
+This will select only the `Tables` nodes for fns with `bar` in their name.
 
 Perhaps you are finding that when you change `foo` you need to re-type-check `bar`,
 but you don't think you should have to. In that case, you might do:
 
 ```
-RUST_DEP_GRAPH_FILTER='Hir&foo -> TypeckItemBody & bar'
+RUST_DEP_GRAPH_FILTER='Hir&foo -> Tables & bar'
 ```
 
 This will dump out all the nodes that lead from `Hir(foo)` to
-`TypeckItemBody(bar)`, from which you can (hopefully) see the source
+`Tables(bar)`, from which you can (hopefully) see the source
 of the erroneous edge.
 
 #### Tracking down incorrect edges
@@ -417,8 +417,8 @@ dep-graph as described in the previous section and open `dep-graph.txt`
 to see something like:
 
     Hir(foo) -> Collect(bar)
-    Collect(bar) -> TypeckItemBody(bar)
-
+    Collect(bar) -> Tables(bar)
+    
 That first edge looks suspicious to you. So you set
 `RUST_FORBID_DEP_GRAPH_EDGE` to `Hir&foo -> Collect&bar`, re-run, and
 then observe the backtrace. Voila, bug fixed!
@@ -440,4 +440,6 @@ To achieve this, the HIR map will detect if the def-id originates in
 an inlined node and add a dependency to a suitable `MetaData` node
 instead. If you are reading a HIR node and are not sure if it may be
 inlined or not, you can use `tcx.map.read(node_id)` and it will detect
-whether the node is inlined or not and do the right thing.
+whether the node is inlined or not and do the right thing.  You can
+also use `tcx.map.is_inlined_def_id()` and
+`tcx.map.is_inlined_node_id()` to test.

src/librustc/dep_graph/dep_node.rs

@@ -78,7 +78,6 @@ pub enum DepNode<D: Clone + Debug> {
     Variance,
     WfCheck(D),
     TypeckItemType(D),
-    TypeckItemBody(D),
     Dropck,
     DropckImpl(D),
     UnusedTraitCheck,
@@ -158,7 +157,6 @@ impl<D: Clone + Debug> DepNode<D> {
             HirBody,
             TransCrateItem,
             TypeckItemType,
-            TypeckItemBody,
             AssociatedItems,
             ItemSignature,
             AssociatedItemDefIds,
@@ -216,7 +214,6 @@ impl<D: Clone + Debug> DepNode<D> {
             CoherenceOrphanCheck(ref d) => op(d).map(CoherenceOrphanCheck),
             WfCheck(ref d) => op(d).map(WfCheck),
             TypeckItemType(ref d) => op(d).map(TypeckItemType),
-            TypeckItemBody(ref d) => op(d).map(TypeckItemBody),
             DropckImpl(ref d) => op(d).map(DropckImpl),
             CheckConst(ref d) => op(d).map(CheckConst),
             IntrinsicCheck(ref d) => op(d).map(IntrinsicCheck),

src/librustc_incremental/persist/dirty_clean.rs

@@ -14,11 +14,11 @@
 //! we will check that a suitable node for that item either appears
 //! or does not appear in the dep-graph, as appropriate:
 //!
-//! - `#[rustc_dirty(label="TypeckItemBody", cfg="rev2")]` if we are
+//! - `#[rustc_dirty(label="Tables", cfg="rev2")]` if we are
 //!   in `#[cfg(rev2)]`, then there MUST NOT be a node
-//!   `DepNode::TypeckItemBody(X)` where `X` is the def-id of the
+//!   `DepNode::Tables(X)` where `X` is the def-id of the
 //!   current node.
-//! - `#[rustc_clean(label="TypeckItemBody", cfg="rev2")]` same as above,
+//! - `#[rustc_clean(label="Tables", cfg="rev2")]` same as above,
 //!   except that the node MUST exist.
 //!
 //! Errors are reported if we are in the suitable configuration but

src/librustc_incremental/persist/preds.rs

@@ -56,7 +56,7 @@ impl<'q> Predecessors<'q> {
 
                 // if -Z query-dep-graph is passed, save more extended data
                 // to enable better unit testing
-                DepNode::TypeckItemBody(_) |
+                DepNode::Tables(_) |
                 DepNode::TransCrateItem(_) => tcx.sess.opts.debugging_opts.query_dep_graph,
 
                 _ => false,

src/librustc_typeck/check/mod.rs

@@ -628,14 +628,14 @@ pub fn check_item_types(ccx: &CrateCtxt) -> CompileResult {
 pub fn check_item_bodies(ccx: &CrateCtxt) -> CompileResult {
     ccx.tcx.sess.track_errors(|| {
         let mut visit = CheckItemBodiesVisitor { ccx: ccx };
-        ccx.tcx.visit_all_item_likes_in_krate(DepNode::TypeckItemBody, &mut visit);
+        ccx.tcx.visit_all_item_likes_in_krate(DepNode::Tables, &mut visit);
 
         // Process deferred obligations, now that all functions
         // bodies have been fully inferred.
         for (&item_id, obligations) in ccx.deferred_obligations.borrow().iter() {
             // Use the same DepNode as for the body of the original function/item.
             let def_id = ccx.tcx.map.local_def_id(item_id);
-            let _task = ccx.tcx.dep_graph.in_task(DepNode::TypeckItemBody(def_id));
+            let _task = ccx.tcx.dep_graph.in_task(DepNode::Tables(def_id));
 
             let param_env = ParameterEnvironment::for_item(ccx.tcx, item_id);
             ccx.tcx.infer_ctxt(param_env, Reveal::NotSpecializable).enter(|infcx| {

src/test/compile-fail/dep-graph-assoc-type-trans.rs

@@ -35,7 +35,7 @@ mod x {
 mod y {
     use Foo;
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn use_char_assoc() {
         // Careful here: in the representation, <char as Foo>::T gets

src/test/compile-fail/dep-graph-caller-callee.rs

@@ -27,7 +27,7 @@ mod y {
     use x;
 
     // These dependencies SHOULD exist:
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn y() {
         x::x();
@@ -39,7 +39,7 @@ mod z {
 
     // These are expected to yield errors, because changes to `x`
     // affect the BODY of `y`, but not its signature.
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR no path
+    #[rustc_then_this_would_need(Tables)] //~ ERROR no path
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR no path
     pub fn z() {
         y::y();

src/test/compile-fail/dep-graph-trait-impl-two-traits-same-method.rs

@@ -39,7 +39,7 @@ mod x {
 mod y {
     use {Foo, Bar};
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
     pub fn with_char() {
         char::method('a');
     }
@@ -48,7 +48,7 @@ mod y {
 mod z {
     use y;
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR no path
+    #[rustc_then_this_would_need(Tables)] //~ ERROR no path
     pub fn z() {
         y::with_char();
     }

src/test/compile-fail/dep-graph-trait-impl-two-traits.rs

@@ -38,7 +38,7 @@ mod x {
 mod y {
     use {Foo, Bar};
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR no path
+    #[rustc_then_this_would_need(Tables)] //~ ERROR no path
     pub fn call_bar() {
         char::bar('a');
     }
@@ -47,7 +47,7 @@ mod y {
 mod z {
     use y;
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR no path
+    #[rustc_then_this_would_need(Tables)] //~ ERROR no path
     pub fn z() {
         y::call_bar();
     }

src/test/compile-fail/dep-graph-trait-impl.rs

@@ -34,25 +34,25 @@ mod x {
 mod y {
     use Foo;
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn with_char() {
         char::method('a');
     }
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn take_foo_with_char() {
         take_foo::<char>('a');
     }
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn with_u32() {
         u32::method(22);
     }
 
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR OK
+    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn take_foo_with_u32() {
         take_foo::<u32>(22);
@@ -66,7 +66,7 @@ mod z {
 
     // These are expected to yield errors, because changes to `x`
     // affect the BODY of `y`, but not its signature.
-    #[rustc_then_this_would_need(TypeckItemBody)] //~ ERROR no path
+    #[rustc_then_this_would_need(Tables)] //~ ERROR no path
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR no path
     pub fn z() {
         y::with_char();