Rollup merge of rust-lang#37688 - eddyb:lazy-8, r=petrochenkov

[8/n] rustc: clean up lookup_item_type and remove TypeScheme.

_This is part of a series ([prev](rust-lang#37676) | [next]()) of patches designed to rework rustc into an out-of-order on-demand pipeline model for both better feature support (e.g. [MIR-based](https://github.com/solson/miri) early constant evaluation) and incremental execution of compiler passes (e.g. type-checking), with beneficial consequences to IDE support as well.
If any motivation is unclear, please ask for additional PR description clarifications or code comments._

<hr>

* `tcx.tcache` -> `tcx.item_types`
* `TypeScheme` (grouping `Ty` and `ty::Generics`) is removed
* `tcx.item_types` entries no longer duplicated in `tcx.tables.node_types`
* `tcx.lookup_item_type(def_id).ty` -> `tcx.item_type(def_id)`
* `tcx.lookup_item_type(def_id).generics` -> `tcx.item_generics(def_id)`
* `tcx.lookup_generics(def_id)` -> `tcx.item_generics(def_id)`
* `tcx.lookup_{super_,}predicates(def_id)` -> `tcx.item_{super_,}predicates(def_id)`

Author: eddyb

src/librustc/dep_graph/dep_tracking_map.rs

@@ -112,15 +112,15 @@ impl<M: DepTrackingMapConfig> MemoizationMap for RefCell<DepTrackingMap<M>> {
     /// switched to `Map(key)`. Therefore, if `op` makes use of any
     /// HIR nodes or shared state accessed through its closure
     /// environment, it must explicitly register a read of that
-    /// state. As an example, see `type_scheme_of_item` in `collect`,
+    /// state. As an example, see `type_of_item` in `collect`,
     /// which looks something like this:
     ///
     /// ```
-    /// fn type_scheme_of_item(..., item: &hir::Item) -> ty::TypeScheme<'tcx> {
+    /// fn type_of_item(..., item: &hir::Item) -> Ty<'tcx> {
     ///     let item_def_id = ccx.tcx.map.local_def_id(it.id);
-    ///     ccx.tcx.tcache.memoized(item_def_id, || {
+    ///     ccx.tcx.item_types.memoized(item_def_id, || {
     ///         ccx.tcx.dep_graph.read(DepNode::Hir(item_def_id)); // (*)
-    ///         compute_type_scheme_of_item(ccx, item)
+    ///         compute_type_of_item(ccx, item)
     ///     });
     /// }
     /// ```

src/librustc/infer/error_reporting.rs

@@ -1443,7 +1443,7 @@ impl<'a, 'gcx, 'tcx> Rebuilder<'a, 'gcx, 'tcx> {
                     match self.tcx.expect_def(cur_ty.id) {
                         Def::Enum(did) | Def::TyAlias(did) |
                         Def::Struct(did) | Def::Union(did) => {
-                            let generics = self.tcx.lookup_generics(did);
+                            let generics = self.tcx.item_generics(did);
 
                             let expected =
                                 generics.regions.len() as u32;

src/librustc/middle/dead.rs

@@ -433,7 +433,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
     }
 
     fn should_warn_about_field(&mut self, field: &hir::StructField) -> bool {
-        let field_type = self.tcx.tables().node_id_to_type(field.id);
+        let field_type = self.tcx.item_type(self.tcx.map.local_def_id(field.id));
         let is_marker_field = match field_type.ty_to_def_id() {
             Some(def_id) => self.tcx.lang_items.items().iter().any(|item| *item == Some(def_id)),
             _ => false

src/librustc/middle/intrinsicck.rs

@@ -51,7 +51,7 @@ struct ExprVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 
 impl<'a, 'gcx, 'tcx> ExprVisitor<'a, 'gcx, 'tcx> {
     fn def_id_is_transmute(&self, def_id: DefId) -> bool {
-        let intrinsic = match self.infcx.tcx.lookup_item_type(def_id).ty.sty {
+        let intrinsic = match self.infcx.tcx.item_type(def_id).sty {
             ty::TyFnDef(.., ref bfty) => bfty.abi == RustIntrinsic,
             _ => return false
         };

src/librustc/middle/liveness.rs

@@ -112,7 +112,7 @@ use self::VarKind::*;
 use dep_graph::DepNode;
 use hir::def::*;
 use hir::pat_util;
-use ty::{self, Ty, TyCtxt, ParameterEnvironment};
+use ty::{self, TyCtxt, ParameterEnvironment};
 use traits::{self, Reveal};
 use ty::subst::Subst;
 use lint;
@@ -1440,28 +1440,30 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
 }
 
 impl<'a, 'tcx> Liveness<'a, 'tcx> {
-    fn fn_ret(&self, id: NodeId) -> ty::Binder<Ty<'tcx>> {
-        let fn_ty = self.ir.tcx.tables().node_id_to_type(id);
-        match fn_ty.sty {
-            ty::TyClosure(closure_def_id, substs) =>
-                self.ir.tcx.closure_type(closure_def_id, substs).sig.output(),
-            _ => fn_ty.fn_ret()
-        }
-    }
-
     fn check_ret(&self,
                  id: NodeId,
                  sp: Span,
-                 _fk: FnKind,
+                 fk: FnKind,
                  entry_ln: LiveNode,
                  body: &hir::Expr)
     {
+        let fn_ty = if let FnKind::Closure(_) = fk {
+            self.ir.tcx.tables().node_id_to_type(id)
+        } else {
+            self.ir.tcx.item_type(self.ir.tcx.map.local_def_id(id))
+        };
+        let fn_ret = match fn_ty.sty {
+            ty::TyClosure(closure_def_id, substs) =>
+                self.ir.tcx.closure_type(closure_def_id, substs).sig.output(),
+            _ => fn_ty.fn_ret()
+        };
+
         // within the fn body, late-bound regions are liberated
         // and must outlive the *call-site* of the function.
         let fn_ret =
             self.ir.tcx.liberate_late_bound_regions(
                 self.ir.tcx.region_maps.call_site_extent(id, body.id),
-                &self.fn_ret(id));
+                &fn_ret);
 
         if !fn_ret.is_never() && self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() {
             let param_env = ParameterEnvironment::for_item(self.ir.tcx, id);

src/librustc/mir/tcx.rs

@@ -125,7 +125,7 @@ impl<'tcx> Lvalue<'tcx> {
             Lvalue::Local(index) =>
                 LvalueTy::Ty { ty: mir.local_decls[index].ty },
             Lvalue::Static(def_id) =>
-                LvalueTy::Ty { ty: tcx.lookup_item_type(def_id).ty },
+                LvalueTy::Ty { ty: tcx.item_type(def_id) },
             Lvalue::Projection(ref proj) =>
                 proj.base.ty(mir, tcx).projection_ty(tcx, &proj.elem),
         }
@@ -188,7 +188,7 @@ impl<'tcx> Rvalue<'tcx> {
                         ))
                     }
                     AggregateKind::Adt(def, _, substs, _) => {
-                        Some(tcx.lookup_item_type(def.did).ty.subst(tcx, substs))
+                        Some(tcx.item_type(def.did).subst(tcx, substs))
                     }
                     AggregateKind::Closure(did, substs) => {
                         Some(tcx.mk_closure_from_closure_substs(did, substs))

src/librustc/traits/fulfill.rs

@@ -154,9 +154,13 @@ impl<'a, 'gcx, 'tcx> DeferredObligation<'tcx> {
     pub fn try_select(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>)
                       -> Option<Vec<PredicateObligation<'tcx>>> {
         if let ty::TyAnon(def_id, substs) = self.predicate.skip_binder().self_ty().sty {
+            let ty = if def_id.is_local() {
+                tcx.item_types.borrow().get(&def_id).cloned()
+            } else {
+                Some(tcx.item_type(def_id))
+            };
             // We can resolve the `impl Trait` to its concrete type.
-            if let Some(ty_scheme) = tcx.opt_lookup_item_type(def_id) {
-                let concrete_ty = ty_scheme.ty.subst(tcx, substs);
+            if let Some(concrete_ty) = ty.subst(tcx, substs) {
                 let predicate = ty::TraitRef {
                     def_id: self.predicate.def_id(),
                     substs: tcx.mk_substs_trait(concrete_ty, &[])

src/librustc/traits/mod.rs

@@ -603,7 +603,7 @@ pub fn get_vtable_methods<'a, 'tcx>(
             // do not hold for this particular set of type parameters.
             // Note that this method could then never be called, so we
             // do not want to try and trans it, in that case (see #23435).
-            let predicates = tcx.lookup_predicates(def_id).instantiate_own(tcx, substs);
+            let predicates = tcx.item_predicates(def_id).instantiate_own(tcx, substs);
             if !normalize_and_test_predicates(tcx, predicates.predicates) {
                 debug!("get_vtable_methods: predicates do not hold");
                 return None;

src/librustc/traits/object_safety.rs

@@ -129,7 +129,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         let trait_def = self.lookup_trait_def(trait_def_id);
         let trait_ref = trait_def.trait_ref.clone();
         let trait_ref = trait_ref.to_poly_trait_ref();
-        let predicates = self.lookup_super_predicates(trait_def_id);
+        let predicates = self.item_super_predicates(trait_def_id);
         predicates
             .predicates
             .into_iter()
@@ -166,7 +166,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         // Search for a predicate like `Self : Sized` amongst the trait bounds.
         let free_substs = self.construct_free_substs(def_id,
             self.region_maps.node_extent(ast::DUMMY_NODE_ID));
-        let predicates = self.lookup_predicates(def_id);
+        let predicates = self.item_predicates(def_id);
         let predicates = predicates.instantiate(self, free_substs).predicates;
         elaborate_predicates(self, predicates)
             .any(|predicate| {
@@ -238,7 +238,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
         // The `Self` type is erased, so it should not appear in list of
         // arguments or return type apart from the receiver.
-        let ref sig = self.lookup_item_type(method.def_id).ty.fn_sig();
+        let ref sig = self.item_type(method.def_id).fn_sig();
         for &input_ty in &sig.0.inputs[1..] {
             if self.contains_illegal_self_type_reference(trait_def_id, input_ty) {
                 return Some(MethodViolationCode::ReferencesSelf);
@@ -249,7 +249,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         }
 
         // We can't monomorphize things like `fn foo<A>(...)`.
-        if !self.lookup_generics(method.def_id).types.is_empty() {
+        if !self.item_generics(method.def_id).types.is_empty() {
             return Some(MethodViolationCode::Generic);
         }
 

src/librustc/traits/project.rs

@@ -311,7 +311,7 @@ impl<'a, 'b, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for AssociatedTypeNormalizer<'a,
             ty::TyAnon(def_id, substs) if !substs.has_escaping_regions() => { // (*)
                 // Only normalize `impl Trait` after type-checking, usually in trans.
                 if self.selcx.projection_mode() == Reveal::All {
-                    let generic_ty = self.tcx().lookup_item_type(def_id).ty;
+                    let generic_ty = self.tcx().item_type(def_id);
                     let concrete_ty = generic_ty.subst(self.tcx(), substs);
                     self.fold_ty(concrete_ty)
                 } else {
@@ -809,7 +809,7 @@ fn assemble_candidates_from_trait_def<'cx, 'gcx, 'tcx>(
     };
 
     // If so, extract what we know from the trait and try to come up with a good answer.
-    let trait_predicates = selcx.tcx().lookup_predicates(def_id);
+    let trait_predicates = selcx.tcx().item_predicates(def_id);
     let bounds = trait_predicates.instantiate(selcx.tcx(), substs);
     let bounds = elaborate_predicates(selcx.tcx(), bounds.predicates);
     assemble_candidates_from_predicates(selcx,
@@ -1313,7 +1313,7 @@ fn confirm_impl_candidate<'cx, 'gcx, 'tcx>(
                        obligation.predicate.trait_ref);
                 tcx.types.err
             } else {
-                tcx.lookup_item_type(node_item.item.def_id).ty
+                tcx.item_type(node_item.item.def_id)
             };
             let substs = translate_substs(selcx.infcx(), impl_def_id, substs, node_item.node);
             Progress {