rename `Tables` to `TypeckTables`

src/librustc/cfg/construct.rs

@@ -18,7 +18,7 @@
 
 struct CFGBuilder<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
     graph: CFGGraph,
     fn_exit: CFGIndex,
     loop_scopes: Vec<LoopScope>,

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(Tables)] //~ ERROR OK
+#[rustc_then_this_would_need(TypeckTables)] //~ ERROR OK
 fn bar() { foo(); }
 
-#[rustc_then_this_would_need(Tables)] //~ ERROR no path
+#[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path
 fn baz() { }
 ```
 
 This will check whether there is a path in the dependency graph from
-`Hir(foo)` to `Tables(bar)`. An error is reported for each
+`Hir(foo)` to `TypeckTables(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='-> Tables'
+RUST_DEP_GRAPH_FILTER='-> TypeckTables'
 ```
 
-would select the predecessors of all `Tables` nodes. Usually though you
-want the `Tables` node for some particular fn, so you might write:
+would select the predecessors of all `TypeckTables` nodes. Usually though you
+want the `TypeckTables` node for some particular fn, so you might write:
 
 ```
-RUST_DEP_GRAPH_FILTER='-> Tables & bar'
+RUST_DEP_GRAPH_FILTER='-> TypeckTables & bar'
 ```
 
-This will select only the `Tables` nodes for fns with `bar` in their name.
+This will select only the `TypeckTables` 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 -> Tables & bar'
+RUST_DEP_GRAPH_FILTER='Hir&foo -> TypeckTables & bar'
 ```
 
 This will dump out all the nodes that lead from `Hir(foo)` to
-`Tables(bar)`, from which you can (hopefully) see the source
+`TypeckTables(bar)`, from which you can (hopefully) see the source
 of the erroneous edge.
 
 #### Tracking down incorrect edges
@@ -417,7 +417,7 @@ dep-graph as described in the previous section and open `dep-graph.txt`
 to see something like:
 
     Hir(foo) -> Collect(bar)
-    Collect(bar) -> Tables(bar)
+    Collect(bar) -> TypeckTables(bar)
     
 That first edge looks suspicious to you. So you set
 `RUST_FORBID_DEP_GRAPH_EDGE` to `Hir&foo -> Collect&bar`, re-run, and

src/librustc/dep_graph/dep_node.rs

@@ -112,7 +112,7 @@ pub enum DepNode<D: Clone + Debug> {
     SizedConstraint(D),
     AssociatedItemDefIds(D),
     InherentImpls(D),
-    Tables(D),
+    TypeckTables(D),
 
     // The set of impls for a given trait. Ultimately, it would be
     // nice to get more fine-grained here (e.g., to include a
@@ -161,7 +161,7 @@ pub fn from_label_string(label: &str, data: D) -> Result<DepNode<D>, ()> {
             ItemSignature,
             AssociatedItemDefIds,
             InherentImpls,
-            Tables,
+            TypeckTables,
             TraitImpls,
             ReprHints,
         }
@@ -229,7 +229,7 @@ pub fn map_def<E, OP>(&self, mut op: OP) -> Option<DepNode<E>>
             SizedConstraint(ref d) => op(d).map(SizedConstraint),
             AssociatedItemDefIds(ref d) => op(d).map(AssociatedItemDefIds),
             InherentImpls(ref d) => op(d).map(InherentImpls),
-            Tables(ref d) => op(d).map(Tables),
+            TypeckTables(ref d) => op(d).map(TypeckTables),
             TraitImpls(ref d) => op(d).map(TraitImpls),
             TraitItems(ref d) => op(d).map(TraitItems),
             ReprHints(ref d) => op(d).map(ReprHints),

src/librustc/infer/mod.rs

@@ -76,23 +76,23 @@ pub struct InferOk<'tcx, T> {
 pub type UnitResult<'tcx> = RelateResult<'tcx, ()>; // "unify result"
 pub type FixupResult<T> = Result<T, FixupError>; // "fixup result"
 
-/// A version of &ty::Tables which can be `Missing` (not needed),
+/// A version of &ty::TypeckTables which can be `Missing` (not needed),
 /// `InProgress` (during typeck) or `Interned` (result of typeck).
 /// Only the `InProgress` version supports `borrow_mut`.
 #[derive(Copy, Clone)]
 pub enum InferTables<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    Interned(&'a ty::Tables<'gcx>),
-    InProgress(&'a RefCell<ty::Tables<'tcx>>),
+    Interned(&'a ty::TypeckTables<'gcx>),
+    InProgress(&'a RefCell<ty::TypeckTables<'tcx>>),
     Missing
 }
 
 pub enum InferTablesRef<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    Interned(&'a ty::Tables<'gcx>),
-    InProgress(Ref<'a, ty::Tables<'tcx>>)
+    Interned(&'a ty::TypeckTables<'gcx>),
+    InProgress(Ref<'a, ty::TypeckTables<'tcx>>)
 }
 
 impl<'a, 'gcx, 'tcx> Deref for InferTablesRef<'a, 'gcx, 'tcx> {
-    type Target = ty::Tables<'tcx>;
+    type Target = ty::TypeckTables<'tcx>;
     fn deref(&self) -> &Self::Target {
         match *self {
             InferTablesRef::Interned(tables) => tables,
@@ -112,7 +112,7 @@ pub fn borrow(self) -> InferTablesRef<'a, 'gcx, 'tcx> {
         }
     }
 
-    pub fn expect_interned(self) -> &'a ty::Tables<'gcx> {
+    pub fn expect_interned(self) -> &'a ty::TypeckTables<'gcx> {
         match self {
             InferTables::Interned(tables) => tables,
             InferTables::InProgress(_) => {
@@ -124,7 +124,7 @@ pub fn expect_interned(self) -> &'a ty::Tables<'gcx> {
         }
     }
 
-    pub fn borrow_mut(self) -> RefMut<'a, ty::Tables<'tcx>> {
+    pub fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
         match self {
             InferTables::Interned(_) => {
                 bug!("InferTables: infcx.tables.borrow_mut() outside of type-checking");
@@ -407,15 +407,15 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
 pub trait InferEnv<'a, 'tcx> {
     fn to_parts(self, tcx: TyCtxt<'a, 'tcx, 'tcx>)
-                -> (Option<&'a ty::Tables<'tcx>>,
-                    Option<ty::Tables<'tcx>>,
+                -> (Option<&'a ty::TypeckTables<'tcx>>,
+                    Option<ty::TypeckTables<'tcx>>,
                     Option<ty::ParameterEnvironment<'tcx>>);
 }
 
 impl<'a, 'tcx> InferEnv<'a, 'tcx> for () {
     fn to_parts(self, _: TyCtxt<'a, 'tcx, 'tcx>)
-                -> (Option<&'a ty::Tables<'tcx>>,
-                    Option<ty::Tables<'tcx>>,
+                -> (Option<&'a ty::TypeckTables<'tcx>>,
+                    Option<ty::TypeckTables<'tcx>>,
                     Option<ty::ParameterEnvironment<'tcx>>) {
         (None, None, None)
     }
@@ -423,26 +423,26 @@ fn to_parts(self, _: TyCtxt<'a, 'tcx, 'tcx>)
 
 impl<'a, 'tcx> InferEnv<'a, 'tcx> for ty::ParameterEnvironment<'tcx> {
     fn to_parts(self, _: TyCtxt<'a, 'tcx, 'tcx>)
-                -> (Option<&'a ty::Tables<'tcx>>,
-                    Option<ty::Tables<'tcx>>,
+                -> (Option<&'a ty::TypeckTables<'tcx>>,
+                    Option<ty::TypeckTables<'tcx>>,
                     Option<ty::ParameterEnvironment<'tcx>>) {
         (None, None, Some(self))
     }
 }
 
-impl<'a, 'tcx> InferEnv<'a, 'tcx> for (&'a ty::Tables<'tcx>, ty::ParameterEnvironment<'tcx>) {
+impl<'a, 'tcx> InferEnv<'a, 'tcx> for (&'a ty::TypeckTables<'tcx>, ty::ParameterEnvironment<'tcx>) {
     fn to_parts(self, _: TyCtxt<'a, 'tcx, 'tcx>)
-                -> (Option<&'a ty::Tables<'tcx>>,
-                    Option<ty::Tables<'tcx>>,
+                -> (Option<&'a ty::TypeckTables<'tcx>>,
+                    Option<ty::TypeckTables<'tcx>>,
                     Option<ty::ParameterEnvironment<'tcx>>) {
         (Some(self.0), None, Some(self.1))
     }
 }
 
-impl<'a, 'tcx> InferEnv<'a, 'tcx> for (ty::Tables<'tcx>, ty::ParameterEnvironment<'tcx>) {
+impl<'a, 'tcx> InferEnv<'a, 'tcx> for (ty::TypeckTables<'tcx>, ty::ParameterEnvironment<'tcx>) {
     fn to_parts(self, _: TyCtxt<'a, 'tcx, 'tcx>)
-                -> (Option<&'a ty::Tables<'tcx>>,
-                    Option<ty::Tables<'tcx>>,
+                -> (Option<&'a ty::TypeckTables<'tcx>>,
+                    Option<ty::TypeckTables<'tcx>>,
                     Option<ty::ParameterEnvironment<'tcx>>) {
         (None, Some(self.0), Some(self.1))
     }
@@ -450,8 +450,8 @@ fn to_parts(self, _: TyCtxt<'a, 'tcx, 'tcx>)
 
 impl<'a, 'tcx> InferEnv<'a, 'tcx> for hir::BodyId {
     fn to_parts(self, tcx: TyCtxt<'a, 'tcx, 'tcx>)
-                -> (Option<&'a ty::Tables<'tcx>>,
-                    Option<ty::Tables<'tcx>>,
+                -> (Option<&'a ty::TypeckTables<'tcx>>,
+                    Option<ty::TypeckTables<'tcx>>,
                     Option<ty::ParameterEnvironment<'tcx>>) {
         let item_id = tcx.map.body_owner(self);
         (Some(tcx.item_tables(tcx.map.local_def_id(item_id))),
@@ -466,8 +466,8 @@ fn to_parts(self, tcx: TyCtxt<'a, 'tcx, 'tcx>)
 pub struct InferCtxtBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     global_tcx: TyCtxt<'a, 'gcx, 'gcx>,
     arena: DroplessArena,
-    fresh_tables: Option<RefCell<ty::Tables<'tcx>>>,
-    tables: Option<&'a ty::Tables<'gcx>>,
+    fresh_tables: Option<RefCell<ty::TypeckTables<'tcx>>>,
+    tables: Option<&'a ty::TypeckTables<'gcx>>,
     param_env: Option<ty::ParameterEnvironment<'gcx>>,
     projection_mode: Reveal,
 }

src/librustc/lint/context.rs

@@ -337,7 +337,7 @@ pub struct LateContext<'a, 'tcx: 'a> {
     pub tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
     /// Side-tables for the body we are in.
-    pub tables: &'a ty::Tables<'tcx>,
+    pub tables: &'a ty::TypeckTables<'tcx>,
 
     /// The crate being checked.
     pub krate: &'a hir::Crate,
@@ -1212,7 +1212,7 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let lint_store = mem::replace(&mut *tcx.sess.lint_store.borrow_mut(), LintStore::new());
     let mut cx = LateContext {
         tcx: tcx,
-        tables: &ty::Tables::empty(),
+        tables: &ty::TypeckTables::empty(),
         krate: krate,
         access_levels: access_levels,
         lints: lint_store,

src/librustc/middle/dead.rs

@@ -49,7 +49,7 @@ fn should_explore<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 struct MarkSymbolVisitor<'a, 'tcx: 'a> {
     worklist: Vec<ast::NodeId>,
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
     live_symbols: Box<FxHashSet<ast::NodeId>>,
     struct_has_extern_repr: bool,
     ignore_non_const_paths: bool,
@@ -392,7 +392,7 @@ fn find_live<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let mut symbol_visitor = MarkSymbolVisitor {
         worklist: worklist,
         tcx: tcx,
-        tables: &ty::Tables::empty(),
+        tables: &ty::TypeckTables::empty(),
         live_symbols: box FxHashSet(),
         struct_has_extern_repr: false,
         ignore_non_const_paths: false,

src/librustc/middle/effect.rs

@@ -52,7 +52,7 @@ fn type_is_unsafe_function(ty: Ty) -> bool {
 
 struct EffectCheckVisitor<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
 
     /// Whether we're in an unsafe context.
     unsafe_context: UnsafeContext,
@@ -245,7 +245,7 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 
     let mut visitor = EffectCheckVisitor {
         tcx: tcx,
-        tables: &ty::Tables::empty(),
+        tables: &ty::TypeckTables::empty(),
         unsafe_context: UnsafeContext::new(SafeContext),
     };
 

src/librustc/middle/liveness.rs

@@ -512,7 +512,7 @@ struct Specials {
 
 struct Liveness<'a, 'tcx: 'a> {
     ir: &'a mut IrMaps<'a, 'tcx>,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
     s: Specials,
     successors: Vec<LiveNode>,
     users: Vec<Users>,

src/librustc/middle/reachable.rs

@@ -79,7 +79,7 @@ fn method_might_be_inlined<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 struct ReachableContext<'a, 'tcx: 'a> {
     // The type context.
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
     // The set of items which must be exported in the linkage sense.
     reachable_symbols: NodeSet,
     // A worklist of item IDs. Each item ID in this worklist will be inlined
@@ -370,7 +370,7 @@ pub fn find_reachable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     });
     let mut reachable_context = ReachableContext {
         tcx: tcx,
-        tables: &ty::Tables::empty(),
+        tables: &ty::TypeckTables::empty(),
         reachable_symbols: NodeSet(),
         worklist: Vec::new(),
         any_library: any_library,

src/librustc/ty/context.rs

@@ -65,7 +65,7 @@ pub struct GlobalArenas<'tcx> {
     trait_def: TypedArena<ty::TraitDef>,
     adt_def: TypedArena<ty::AdtDef>,
     mir: TypedArena<RefCell<Mir<'tcx>>>,
-    tables: TypedArena<ty::Tables<'tcx>>,
+    tables: TypedArena<ty::TypeckTables<'tcx>>,
 }
 
 impl<'tcx> GlobalArenas<'tcx> {
@@ -192,7 +192,7 @@ pub struct CommonTypes<'tcx> {
 }
 
 #[derive(RustcEncodable, RustcDecodable)]
-pub struct Tables<'tcx> {
+pub struct TypeckTables<'tcx> {
     /// Resolved definitions for `<T>::X` associated paths.
     pub type_relative_path_defs: NodeMap<Def>,
 
@@ -234,9 +234,9 @@ pub struct Tables<'tcx> {
     pub fru_field_types: NodeMap<Vec<Ty<'tcx>>>
 }
 
-impl<'tcx> Tables<'tcx> {
-    pub fn empty() -> Tables<'tcx> {
-        Tables {
+impl<'tcx> TypeckTables<'tcx> {
+    pub fn empty() -> TypeckTables<'tcx> {
+        TypeckTables {
             type_relative_path_defs: NodeMap(),
             node_types: FxHashMap(),
             item_substs: NodeMap(),
@@ -402,7 +402,7 @@ pub struct GlobalCtxt<'tcx> {
     free_region_maps: RefCell<NodeMap<FreeRegionMap>>,
     // FIXME: jroesch make this a refcell
 
-    pub tables: RefCell<DepTrackingMap<maps::Tables<'tcx>>>,
+    pub tables: RefCell<DepTrackingMap<maps::TypeckTables<'tcx>>>,
 
     /// Maps from a trait item to the trait item "descriptor"
     pub associated_items: RefCell<DepTrackingMap<maps::AssociatedItems<'tcx>>>,
@@ -654,7 +654,7 @@ pub fn alloc_mir(self, mir: Mir<'gcx>) -> &'gcx RefCell<Mir<'gcx>> {
         self.global_arenas.mir.alloc(RefCell::new(mir))
     }
 
-    pub fn alloc_tables(self, tables: ty::Tables<'gcx>) -> &'gcx ty::Tables<'gcx> {
+    pub fn alloc_tables(self, tables: ty::TypeckTables<'gcx>) -> &'gcx ty::TypeckTables<'gcx> {
         self.global_arenas.tables.alloc(tables)
     }
 

src/librustc/ty/maps.rs

@@ -48,4 +48,4 @@ fn to_dep_node(key: &$key) -> DepNode<DefId> { DepNode::$node_name(*key) }
 dep_map_ty! { Mir: Mir(DefId) -> &'tcx RefCell<mir::Mir<'tcx>> }
 dep_map_ty! { ClosureKinds: ItemSignature(DefId) -> ty::ClosureKind }
 dep_map_ty! { ClosureTypes: ItemSignature(DefId) -> ty::ClosureTy<'tcx> }
-dep_map_ty! { Tables: Tables(DefId) -> &'tcx ty::Tables<'tcx> }
+dep_map_ty! { TypeckTables: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx> }

src/librustc/ty/mod.rs

@@ -69,7 +69,7 @@
 
 pub use self::contents::TypeContents;
 pub use self::context::{TyCtxt, GlobalArenas, tls};
-pub use self::context::{Lift, Tables};
+pub use self::context::{Lift, TypeckTables};
 
 pub use self::trait_def::{TraitDef, TraitFlags};
 
@@ -1917,11 +1917,11 @@ pub fn to_user_str(&self) -> &'static str {
 }
 
 impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
-    pub fn body_tables(self, body: hir::BodyId) -> &'gcx Tables<'gcx> {
+    pub fn body_tables(self, body: hir::BodyId) -> &'gcx TypeckTables<'gcx> {
         self.item_tables(self.map.body_owner_def_id(body))
     }
 
-    pub fn item_tables(self, def_id: DefId) -> &'gcx Tables<'gcx> {
+    pub fn item_tables(self, def_id: DefId) -> &'gcx TypeckTables<'gcx> {
         self.tables.memoize(def_id, || {
             if def_id.is_local() {
                 // Closures' tables come from their outermost function,

src/librustc_const_eval/check_match.rs

@@ -69,7 +69,7 @@ fn create_e0004<'a>(sess: &'a Session, sp: Span, error_message: String) -> Diagn
 
 struct MatchVisitor<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
     param_env: &'a ty::ParameterEnvironment<'tcx>
 }
 

src/librustc_const_eval/eval.rs

@@ -52,7 +52,7 @@
 
 fn lookup_variant_by_id<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                   variant_def: DefId)
-                                  -> Option<(&'tcx Expr, Option<&'a ty::Tables<'tcx>>)> {
+                                  -> Option<(&'tcx Expr, Option<&'a ty::TypeckTables<'tcx>>)> {
     if let Some(variant_node_id) = tcx.map.as_local_node_id(variant_def) {
         let enum_node_id = tcx.map.get_parent(variant_node_id);
         if let Some(ast_map::NodeItem(it)) = tcx.map.find(enum_node_id) {
@@ -81,7 +81,7 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                         def_id: DefId,
                                         substs: Option<&'tcx Substs<'tcx>>)
                                         -> Option<(&'tcx Expr,
-                                                   Option<&'a ty::Tables<'tcx>>,
+                                                   Option<&'a ty::TypeckTables<'tcx>>,
                                                    Option<ty::Ty<'tcx>>)> {
     if let Some(node_id) = tcx.map.as_local_node_id(def_id) {
         match tcx.map.find(node_id) {
@@ -154,7 +154,7 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
 
 fn lookup_const_fn_by_id<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
-                                   -> Option<(&'tcx hir::Body, Option<&'a ty::Tables<'tcx>>)>
+                                   -> Option<(&'tcx hir::Body, Option<&'a ty::TypeckTables<'tcx>>)>
 {
     if let Some(node_id) = tcx.map.as_local_node_id(def_id) {
         FnLikeNode::from_node(tcx.map.get(node_id)).and_then(|fn_like| {
@@ -226,7 +226,7 @@ pub fn note_const_eval_err<'a, 'tcx>(
 
 pub struct ConstContext<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    tables: Option<&'a ty::Tables<'tcx>>,
+    tables: Option<&'a ty::TypeckTables<'tcx>>,
     fn_args: Option<DefIdMap<ConstVal>>
 }
 
@@ -240,7 +240,7 @@ pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>, body: hir::BodyId) -> Self {
         }
     }
 
-    pub fn with_tables(tcx: TyCtxt<'a, 'tcx, 'tcx>, tables: &'a ty::Tables<'tcx>) -> Self {
+    pub fn with_tables(tcx: TyCtxt<'a, 'tcx, 'tcx>, tables: &'a ty::TypeckTables<'tcx>) -> Self {
         ConstContext {
             tcx: tcx,
             tables: Some(tables),
@@ -920,10 +920,10 @@ fn infer<'a, 'tcx>(i: ConstInt,
 fn resolve_trait_associated_const<'a, 'tcx: 'a>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     trait_item_id: DefId,
-    default_value: Option<(&'tcx Expr, Option<&'a ty::Tables<'tcx>>, Option<ty::Ty<'tcx>>)>,
+    default_value: Option<(&'tcx Expr, Option<&'a ty::TypeckTables<'tcx>>, Option<ty::Ty<'tcx>>)>,
     trait_id: DefId,
     rcvr_substs: &'tcx Substs<'tcx>
-) -> Option<(&'tcx Expr, Option<&'a ty::Tables<'tcx>>, Option<ty::Ty<'tcx>>)>
+) -> Option<(&'tcx Expr, Option<&'a ty::TypeckTables<'tcx>>, Option<ty::Ty<'tcx>>)>
 {
     let trait_ref = ty::Binder(ty::TraitRef::new(trait_id, rcvr_substs));
     debug!("resolve_trait_associated_const: trait_ref={:?}",

src/librustc_const_eval/pattern.rs

@@ -264,13 +264,13 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
 pub struct PatternContext<'a, 'gcx: 'tcx, 'tcx: 'a> {
     pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
-    pub tables: &'a ty::Tables<'gcx>,
+    pub tables: &'a ty::TypeckTables<'gcx>,
     pub errors: Vec<PatternError>,
 }
 
 impl<'a, 'gcx, 'tcx> Pattern<'tcx> {
     pub fn from_hir(tcx: TyCtxt<'a, 'gcx, 'tcx>,
-                    tables: &'a ty::Tables<'gcx>,
+                    tables: &'a ty::TypeckTables<'gcx>,
                     pat: &hir::Pat) -> Self {
         let mut pcx = PatternContext::new(tcx, tables);
         let result = pcx.lower_pattern(pat);
@@ -283,7 +283,7 @@ pub fn from_hir(tcx: TyCtxt<'a, 'gcx, 'tcx>,
 }
 
 impl<'a, 'gcx, 'tcx> PatternContext<'a, 'gcx, 'tcx> {
-    pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>, tables: &'a ty::Tables<'gcx>) -> Self {
+    pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>, tables: &'a ty::TypeckTables<'gcx>) -> Self {
         PatternContext { tcx: tcx, tables: tables, errors: vec![] }
     }
 

src/librustc_driver/pretty.rs

@@ -237,7 +237,7 @@ fn call_with_pp_support_hir<'tcx, A, B, F>(&self,
                                                                  arenas,
                                                                  id,
                                                                  |tcx, _, _, _| {
-                    let empty_tables = ty::Tables::empty();
+                    let empty_tables = ty::TypeckTables::empty();
                     let annotation = TypedAnnotation {
                         tcx: tcx,
                         tables: Cell::new(&empty_tables)
@@ -493,7 +493,7 @@ fn post(&self, s: &mut pprust::State, node: pprust::AnnNode) -> io::Result<()> {
 
 struct TypedAnnotation<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    tables: Cell<&'a ty::Tables<'tcx>>,
+    tables: Cell<&'a ty::TypeckTables<'tcx>>,
 }
 
 impl<'b, 'tcx> HirPrinterSupport<'tcx> for TypedAnnotation<'b, 'tcx> {

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="Tables", cfg="rev2")]` if we are
+//! - `#[rustc_dirty(label="TypeckTables", cfg="rev2")]` if we are
 //!   in `#[cfg(rev2)]`, then there MUST NOT be a node
-//!   `DepNode::Tables(X)` where `X` is the def-id of the
+//!   `DepNode::TypeckTables(X)` where `X` is the def-id of the
 //!   current node.
-//! - `#[rustc_clean(label="Tables", cfg="rev2")]` same as above,
+//! - `#[rustc_clean(label="TypeckTables", 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 @@ pub fn new(query: &'q DepGraphQuery<DefId>, hcx: &mut HashContext) -> Self {
 
                 // if -Z query-dep-graph is passed, save more extended data
                 // to enable better unit testing
-                DepNode::Tables(_) |
+                DepNode::TypeckTables(_) |
                 DepNode::TransCrateItem(_) => tcx.sess.opts.debugging_opts.query_dep_graph,
 
                 _ => false,

src/librustc_metadata/astencode.rs

@@ -21,7 +21,7 @@
 #[derive(RustcEncodable, RustcDecodable)]
 pub struct Ast<'tcx> {
     pub body: Lazy<hir::Body>,
-    pub tables: Lazy<ty::Tables<'tcx>>,
+    pub tables: Lazy<ty::TypeckTables<'tcx>>,
     pub nested_bodies: LazySeq<hir::Body>,
     pub rvalue_promotable_to_static: bool,
 }

src/librustc_mir/hair/cx/mod.rs

@@ -170,7 +170,7 @@ pub fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> {
         self.tcx
     }
 
-    pub fn tables(&self) -> &'a ty::Tables<'gcx> {
+    pub fn tables(&self) -> &'a ty::TypeckTables<'gcx> {
         self.infcx.tables.expect_interned()
     }
 

src/librustc_passes/consts.rs

@@ -60,7 +60,7 @@ struct CheckCrateVisitor<'a, 'tcx: 'a> {
     promotable: bool,
     mut_rvalue_borrows: NodeSet,
     param_env: ty::ParameterEnvironment<'tcx>,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
 }
 
 impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
@@ -462,7 +462,7 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
     tcx.visit_all_item_likes_in_krate(DepNode::CheckConst,
                                       &mut CheckCrateVisitor {
                                           tcx: tcx,
-                                          tables: &ty::Tables::empty(),
+                                          tables: &ty::TypeckTables::empty(),
                                           in_fn: false,
                                           promotable: false,
                                           mut_rvalue_borrows: NodeSet(),

src/librustc_privacy/lib.rs

@@ -392,7 +392,7 @@ struct PrivacyVisitor<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     curitem: DefId,
     in_foreign: bool,
-    tables: &'a ty::Tables<'tcx>,
+    tables: &'a ty::TypeckTables<'tcx>,
 }
 
 impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
@@ -1212,7 +1212,7 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         curitem: DefId::local(CRATE_DEF_INDEX),
         in_foreign: false,
         tcx: tcx,
-        tables: &ty::Tables::empty(),
+        tables: &ty::TypeckTables::empty(),
     };
     intravisit::walk_crate(&mut visitor, krate);
 

src/librustc_save_analysis/lib.rs

@@ -84,7 +84,7 @@ pub enum Row {
 
 pub struct SaveContext<'l, 'tcx: 'l> {
     tcx: TyCtxt<'l, 'tcx, 'tcx>,
-    tables: &'l ty::Tables<'tcx>,
+    tables: &'l ty::TypeckTables<'tcx>,
     analysis: &'l ty::CrateAnalysis<'tcx>,
     span_utils: SpanUtils<'tcx>,
 }
@@ -899,7 +899,7 @@ pub fn process_crate<'l, 'tcx>(tcx: TyCtxt<'l, 'tcx, 'tcx>,
 
     let save_ctxt = SaveContext {
         tcx: tcx,
-        tables: &ty::Tables::empty(),
+        tables: &ty::TypeckTables::empty(),
         analysis: analysis,
         span_utils: SpanUtils::new(&tcx.sess),
     };

src/librustc_typeck/check/mod.rs

@@ -483,7 +483,7 @@ pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 impl<'a, 'gcx, 'tcx> CrateCtxt<'a, 'gcx> {
     pub fn inherited(&'a self, id: ast::NodeId)
                      -> InheritedBuilder<'a, 'gcx, 'tcx> {
-        let tables = ty::Tables::empty();
+        let tables = ty::TypeckTables::empty();
         let param_env = ParameterEnvironment::for_item(self.tcx, id);
         InheritedBuilder {
             ccx: self,
@@ -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::Tables, &mut visit);
+        ccx.tcx.visit_all_item_likes_in_krate(DepNode::TypeckTables, &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::Tables(def_id));
+            let _task = ccx.tcx.dep_graph.in_task(DepNode::TypeckTables(def_id));
 
             let param_env = ParameterEnvironment::for_item(ccx.tcx, item_id);
             ccx.tcx.infer_ctxt(param_env, Reveal::NotSpecializable).enter(|infcx| {

src/librustc_typeck/check/writeback.rs

@@ -68,7 +68,7 @@ pub fn resolve_type_vars_in_body(&self, body: &'gcx hir::Body) {
 struct WritebackCx<'cx, 'gcx: 'cx+'tcx, 'tcx: 'cx> {
     fcx: &'cx FnCtxt<'cx, 'gcx, 'tcx>,
 
-    tables: ty::Tables<'gcx>,
+    tables: ty::TypeckTables<'gcx>,
 
     // Mapping from free regions of the function to the
     // early-bound versions of them, visible from the
@@ -81,7 +81,7 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
     fn new(fcx: &'cx FnCtxt<'cx, 'gcx, 'tcx>) -> WritebackCx<'cx, 'gcx, 'tcx> {
         let mut wbcx = WritebackCx {
             fcx: fcx,
-            tables: ty::Tables::empty(),
+            tables: ty::TypeckTables::empty(),
             free_to_bound_regions: DefIdMap()
         };
 

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(Tables)] //~ ERROR OK
+    #[rustc_then_this_would_need(TypeckTables)] //~ 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(Tables)] //~ ERROR OK
+    #[rustc_then_this_would_need(TypeckTables)] //~ 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(Tables)] //~ ERROR no path
+    #[rustc_then_this_would_need(TypeckTables)] //~ 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 @@ impl Bar for char { }
 mod y {
     use {Foo, Bar};
 
-    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
+    #[rustc_then_this_would_need(TypeckTables)] //~ ERROR OK
     pub fn with_char() {
         char::method('a');
     }
@@ -48,7 +48,7 @@ pub fn with_char() {
 mod z {
     use y;
 
-    #[rustc_then_this_would_need(Tables)] //~ ERROR no path
+    #[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path
     pub fn z() {
         y::with_char();
     }

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

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

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

@@ -34,25 +34,25 @@ impl Foo for u32 { }
 mod y {
     use Foo;
 
-    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
+    #[rustc_then_this_would_need(TypeckTables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn with_char() {
         char::method('a');
     }
 
-    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
+    #[rustc_then_this_would_need(TypeckTables)] //~ 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(Tables)] //~ ERROR OK
+    #[rustc_then_this_would_need(TypeckTables)] //~ ERROR OK
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR OK
     pub fn with_u32() {
         u32::method(22);
     }
 
-    #[rustc_then_this_would_need(Tables)] //~ ERROR OK
+    #[rustc_then_this_would_need(TypeckTables)] //~ 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(Tables)] //~ ERROR no path
+    #[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path
     #[rustc_then_this_would_need(TransCrateItem)] //~ ERROR no path
     pub fn z() {
         y::with_char();

src/test/compile-fail/dep_graph_crosscontaminate_tables.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test that the `Tables` nodes for impl items are independent from
+// Test that the `TypeckTables` nodes for impl items are independent from
 // one another.
 
 // compile-flags: -Z query-dep-graph
@@ -27,7 +27,7 @@ fn new() -> Foo {
     }
 
     // ...should not cause us to recompute the tables for `with`!
-    #[rustc_then_this_would_need(Tables)] //~ ERROR no path
+    #[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path
     fn with(x: u8) -> Foo {
         Foo { x: x }
     }

src/test/incremental/add_private_fn_at_krate_root_cc/struct_point.rs

@@ -32,7 +32,7 @@
 mod fn_calls_methods_in_same_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let x = Point { x: 2.0, y: 2.0 };
         x.distance_from_origin();
@@ -43,7 +43,7 @@ pub fn check() {
 mod fn_calls_free_fn {
     use point::{self, Point};
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let x = Point { x: 2.0, y: 2.0 };
         point::distance_squared(&x);
@@ -54,7 +54,7 @@ pub fn check() {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin() -> Point {
         Point { x: 2.0, y: 2.0 }
     }
@@ -64,7 +64,7 @@ pub fn make_origin() -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -74,7 +74,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/callee_caller_cross_crate/b.rs

@@ -16,12 +16,12 @@
 
 extern crate a;
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn call_function0() {
     a::function0(77);
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn call_function1() {
     a::function1(77);
 }

src/test/incremental/change_add_field/struct_point.rs

@@ -79,7 +79,7 @@ pub fn x(&self) -> f32 {
 mod fn_with_type_in_sig {
     use point::Point;
 
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     pub fn boop(p: Option<&Point>) -> f32 {
         p.map(|p| p.total()).unwrap_or(0.0)
     }
@@ -95,7 +95,7 @@ pub fn boop(p: Option<&Point>) -> f32 {
 mod call_fn_with_type_in_sig {
     use fn_with_type_in_sig;
 
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     pub fn bip() -> f32 {
         fn_with_type_in_sig::boop(None)
     }
@@ -111,7 +111,7 @@ pub fn bip() -> f32 {
 mod fn_with_type_in_body {
     use point::Point;
 
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     pub fn boop() -> f32 {
         Point::origin().total()
     }
@@ -124,7 +124,7 @@ pub fn boop() -> f32 {
 mod call_fn_with_type_in_body {
     use fn_with_type_in_body;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn bip() -> f32 {
         fn_with_type_in_body::boop()
     }
@@ -134,7 +134,7 @@ pub fn bip() -> f32 {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin(p: Point) -> Point {
         Point { ..p }
     }
@@ -144,7 +144,7 @@ pub fn make_origin(p: Point) -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -154,7 +154,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/change_crate_order/main.rs

@@ -28,7 +28,7 @@
 use a::A;
 use b::B;
 
-//? #[rustc_clean(label="Tables", cfg="rpass2")]
+//? #[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn main() {
     A + B;
 }

src/test/incremental/change_private_fn/struct_point.rs

@@ -59,7 +59,7 @@ pub fn translate(&mut self, x: f32, y: f32) {
 mod fn_calls_methods_in_same_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let x = Point { x: 2.0, y: 2.0 };
         x.distance_from_origin();
@@ -70,7 +70,7 @@ pub fn check() {
 mod fn_calls_methods_in_another_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let mut x = Point { x: 2.0, y: 2.0 };
         x.translate(3.0, 3.0);
@@ -81,7 +81,7 @@ pub fn check() {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin() -> Point {
         Point { x: 2.0, y: 2.0 }
     }
@@ -91,7 +91,7 @@ pub fn make_origin() -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -101,7 +101,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/change_private_fn_cc/struct_point.rs

@@ -31,7 +31,7 @@
 mod fn_calls_methods_in_same_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let x = Point { x: 2.0, y: 2.0 };
         x.distance_from_origin();
@@ -42,7 +42,7 @@ pub fn check() {
 mod fn_calls_methods_in_another_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let mut x = Point { x: 2.0, y: 2.0 };
         x.translate(3.0, 3.0);
@@ -53,7 +53,7 @@ pub fn check() {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin() -> Point {
         Point { x: 2.0, y: 2.0 }
     }
@@ -63,7 +63,7 @@ pub fn make_origin() -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -73,7 +73,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/change_private_impl_method/struct_point.rs

@@ -59,7 +59,7 @@ pub fn translate(&mut self, x: f32, y: f32) {
 mod fn_calls_methods_in_same_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let x = Point { x: 2.0, y: 2.0 };
         x.distance_from_origin();
@@ -70,7 +70,7 @@ pub fn check() {
 mod fn_calls_methods_in_another_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let mut x = Point { x: 2.0, y: 2.0 };
         x.translate(3.0, 3.0);
@@ -81,7 +81,7 @@ pub fn check() {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin() -> Point {
         Point { x: 2.0, y: 2.0 }
     }
@@ -91,7 +91,7 @@ pub fn make_origin() -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -101,7 +101,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/change_private_impl_method_cc/struct_point.rs

@@ -32,7 +32,7 @@
 mod fn_calls_methods_in_same_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let x = Point { x: 2.0, y: 2.0 };
         x.distance_from_origin();
@@ -43,7 +43,7 @@ pub fn check() {
 mod fn_calls_methods_in_another_impl {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn dirty() {
         let mut x = Point { x: 2.0, y: 2.0 };
         x.translate(3.0, 3.0);
@@ -54,7 +54,7 @@ pub fn dirty() {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin() -> Point {
         Point { x: 2.0, y: 2.0 }
     }
@@ -64,7 +64,7 @@ pub fn make_origin() -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -74,7 +74,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/change_pub_inherent_method_body/struct_point.rs

@@ -50,7 +50,7 @@ pub fn x(&self) -> f32 {
 mod fn_calls_changed_method {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let p = Point { x: 2.0, y: 2.0 };
         p.distance_from_origin();
@@ -61,7 +61,7 @@ pub fn check() {
 mod fn_calls_another_method {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let p = Point { x: 2.0, y: 2.0 };
         p.x();
@@ -72,7 +72,7 @@ pub fn check() {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin() -> Point {
         Point { x: 2.0, y: 2.0 }
     }
@@ -82,7 +82,7 @@ pub fn make_origin() -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -92,7 +92,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/change_pub_inherent_method_sig/struct_point.rs

@@ -61,7 +61,7 @@ pub fn x(&self) -> f32 {
 mod fn_calls_changed_method {
     use point::Point;
 
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let p = Point { x: 2.0, y: 2.0 };
         p.distance_from_point(None);
@@ -72,7 +72,7 @@ pub fn check() {
 mod fn_calls_another_method {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn check() {
         let p = Point { x: 2.0, y: 2.0 };
         p.x();
@@ -83,7 +83,7 @@ pub fn check() {
 mod fn_make_struct {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn make_origin() -> Point {
         Point { x: 2.0, y: 2.0 }
     }
@@ -93,7 +93,7 @@ pub fn make_origin() -> Point {
 mod fn_read_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn get_x(p: Point) -> f32 {
         p.x
     }
@@ -103,7 +103,7 @@ pub fn get_x(p: Point) -> f32 {
 mod fn_write_field {
     use point::Point;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn inc_x(p: &mut Point) {
         p.x += 1.0;
     }

src/test/incremental/dirty_clean.rs

@@ -35,20 +35,20 @@ pub fn x() -> u32 {
 mod y {
     use x;
 
-    #[rustc_clean(label="Tables", cfg="cfail2")]
+    #[rustc_clean(label="TypeckTables", cfg="cfail2")]
     #[rustc_clean(label="TransCrateItem", cfg="cfail2")]
     pub fn y() {
-        //[cfail2]~^ ERROR `Tables("y::y")` not found in dep graph, but should be clean
+        //[cfail2]~^ ERROR `TypeckTables("y::y")` not found in dep graph, but should be clean
         //[cfail2]~| ERROR `TransCrateItem("y::y")` not found in dep graph, but should be clean
         x::x();
     }
 }
 
 mod z {
-    #[rustc_dirty(label="Tables", cfg="cfail2")]
+    #[rustc_dirty(label="TypeckTables", cfg="cfail2")]
     #[rustc_dirty(label="TransCrateItem", cfg="cfail2")]
     pub fn z() {
-        //[cfail2]~^ ERROR `Tables("z::z")` found in dep graph, but should be dirty
+        //[cfail2]~^ ERROR `TypeckTables("z::z")` found in dep graph, but should be dirty
         //[cfail2]~| ERROR `TransCrateItem("z::z")` found in dep graph, but should be dirty
     }
 }

src/test/incremental/hello_world.rs

@@ -31,7 +31,7 @@ pub fn xxxx() -> i32 {
 mod y {
     use x;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn yyyy() {
         x::xxxx();
     }
@@ -40,7 +40,7 @@ pub fn yyyy() {
 mod z {
     use y;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     pub fn z() {
         y::yyyy();
     }

src/test/incremental/rlib_cross_crate/b.rs

@@ -22,15 +22,15 @@
 
 extern crate a;
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
-#[rustc_clean(label="Tables", cfg="rpass3")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass3")]
 pub fn use_X() -> u32 {
     let x: a::X = 22;
     x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
-#[rustc_clean(label="Tables", cfg="rpass3")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass3")]
 pub fn use_Y() {
     let x: a::Y = 'c';
 }

src/test/incremental/string_constant.rs

@@ -27,7 +27,7 @@ pub fn x() {
     }
 
     #[cfg(rpass2)]
-    #[rustc_dirty(label="Tables", cfg="rpass2")]
+    #[rustc_dirty(label="TypeckTables", cfg="rpass2")]
     #[rustc_dirty(label="TransCrateItem", cfg="rpass2")]
     pub fn x() {
         println!("{}", "2");
@@ -37,7 +37,7 @@ pub fn x() {
 mod y {
     use x;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     #[rustc_clean(label="TransCrateItem", cfg="rpass2")]
     pub fn y() {
         x::x();
@@ -47,7 +47,7 @@ pub fn y() {
 mod z {
     use y;
 
-    #[rustc_clean(label="Tables", cfg="rpass2")]
+    #[rustc_clean(label="TypeckTables", cfg="rpass2")]
     #[rustc_clean(label="TransCrateItem", cfg="rpass2")]
     pub fn z() {
         y::y();

src/test/incremental/struct_add_field.rs

@@ -31,17 +31,17 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_X(x: X) -> u32 {
     x.x as u32
 }
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn use_Y() {
     let x: Y = Y { y: 'c' };
 }

src/test/incremental/struct_change_field_name.rs

@@ -34,7 +34,7 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_dirty(label="Tables", cfg="cfail2")]
+#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
 pub fn use_X() -> u32 {
     let x: X = X { x: 22 };
     //[cfail2]~^ ERROR struct `X` has no field named `x`
@@ -42,13 +42,13 @@ pub fn use_X() -> u32 {
     //[cfail2]~^ ERROR no field `x` on type `X`
 }
 
-#[rustc_dirty(label="Tables", cfg="cfail2")]
+#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
     //[cfail2]~^ ERROR no field `x` on type `X`
 }
 
-#[rustc_clean(label="Tables", cfg="cfail2")]
+#[rustc_clean(label="TypeckTables", cfg="cfail2")]
 pub fn use_Y() {
     let x: Y = Y { y: 'c' };
 }

src/test/incremental/struct_change_field_type.rs

@@ -34,19 +34,19 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_X() -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
 }
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_EmbedX(x: EmbedX) -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn use_Y() {
     let x: Y = Y { y: 'c' };
 }

src/test/incremental/struct_change_field_type_cross_crate/b.rs

@@ -18,18 +18,18 @@
 
 use a::*;
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_X() -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
 }
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn use_Y() {
     let x: Y = Y { y: 'c' };
 }

src/test/incremental/struct_change_nothing.rs

@@ -34,19 +34,19 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn use_X() -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn use_EmbedX(x: EmbedX) -> u32 {
     let x: X = X { x: 22 };
     x.x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn use_Y() {
     let x: Y = Y { y: 'c' };
 }

src/test/incremental/struct_remove_field.rs

@@ -35,17 +35,17 @@ pub struct Y {
     pub y: char
 }
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_X(x: X) -> u32 {
     x.x as u32
 }
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
 pub fn use_EmbedX(embed: EmbedX) -> u32 {
     embed.x.x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
 pub fn use_Y() {
     let x: Y = Y { y: 'c' };
 }

src/test/incremental/type_alias_cross_crate/b.rs

@@ -16,15 +16,15 @@
 
 extern crate a;
 
-#[rustc_dirty(label="Tables", cfg="rpass2")]
-#[rustc_clean(label="Tables", cfg="rpass3")]
+#[rustc_dirty(label="TypeckTables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass3")]
 pub fn use_X() -> u32 {
     let x: a::X = 22;
     x as u32
 }
 
-#[rustc_clean(label="Tables", cfg="rpass2")]
-#[rustc_clean(label="Tables", cfg="rpass3")]
+#[rustc_clean(label="TypeckTables", cfg="rpass2")]
+#[rustc_clean(label="TypeckTables", cfg="rpass3")]
 pub fn use_Y() {
     let x: a::Y = 'c';
 }