rustc: avoid using subst::VecPerParamSpace::{empty,new} directly.

Author: eddyb

src/librustc/traits/error_reporting.rs

@@ -180,9 +180,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
              ity.ty);
 
         let rps = self.region_vars_for_defs(obligation.cause.span, rps);
-        let mut substs = subst::Substs::new(
-            subst::VecPerParamSpace::empty(),
-            subst::VecPerParamSpace::new(Vec::new(), rps, Vec::new()));
+        let mut substs = subst::Substs::new_type(vec![], rps);
         self.type_vars_for_defs(obligation.cause.span,
                                 TypeSpace,
                                 &mut substs,

src/librustc/ty/mod.rs

@@ -429,6 +429,15 @@ pub struct ItemVariances {
     pub regions: VecPerParamSpace<Variance>,
 }
 
+impl ItemVariances {
+    pub fn empty() -> ItemVariances {
+        ItemVariances {
+            types: VecPerParamSpace::empty(),
+            regions: VecPerParamSpace::empty(),
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, RustcDecodable, RustcEncodable, Copy)]
 pub enum Variance {
     Covariant,      // T<A> <: T<B> iff A <: B -- e.g., function return type
@@ -2864,22 +2873,20 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn construct_free_substs(self, generics: &Generics<'gcx>,
                                  free_id_outlive: CodeExtent) -> Substs<'gcx> {
         // map T => T
-        let mut types = VecPerParamSpace::empty();
-        for def in generics.types.as_full_slice() {
+        let types = generics.types.map(|def| {
             debug!("construct_parameter_environment(): push_types_from_defs: def={:?}",
                     def);
-            types.push(def.space, self.global_tcx().mk_param_from_def(def));
-        }
+            self.global_tcx().mk_param_from_def(def)
+        });
 
         // map bound 'a => free 'a
-        let mut regions = VecPerParamSpace::empty();
-        for def in generics.regions.as_full_slice() {
+        let regions = generics.regions.map(|def| {
             let region =
                 ReFree(FreeRegion { scope: free_id_outlive,
                                     bound_region: def.to_bound_region() });
             debug!("push_region_params {:?}", region);
-            regions.push(def.space, region);
-        }
+            region
+        });
 
         Substs {
             types: types,

src/librustc/ty/subst.rs

@@ -41,6 +41,14 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
         Substs { types: t, regions: r }
     }
 
+    pub fn new_fn(t: Vec<Ty<'tcx>>,
+                  r: Vec<ty::Region>)
+                  -> Substs<'tcx>
+    {
+        Substs::new(VecPerParamSpace::new(vec![], vec![], t),
+                    VecPerParamSpace::new(vec![], vec![], r))
+    }
+
     pub fn new_type(t: Vec<Ty<'tcx>>,
                     r: Vec<ty::Region>)
                     -> Substs<'tcx>

src/librustc_metadata/decoder.rs

@@ -35,7 +35,6 @@ use middle::cstore::{DefLike, DlDef, DlField, DlImpl, tls};
 use rustc::hir::def::Def;
 use rustc::hir::def_id::{DefId, DefIndex};
 use middle::lang_items;
-use rustc::ty::subst;
 use rustc::ty::{ImplContainer, TraitContainer};
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable, VariantKind};
 
@@ -1580,25 +1579,24 @@ fn doc_generics<'a, 'tcx>(base_doc: rbml::Doc,
 {
     let doc = reader::get_doc(base_doc, tag);
 
-    let mut types = subst::VecPerParamSpace::empty();
+    let mut generics = ty::Generics::empty();
     for p in reader::tagged_docs(doc, tag_type_param_def) {
         let bd =
             TyDecoder::with_doc(tcx, cdata.cnum, p,
                                 &mut |did| translate_def_id(cdata, did))
             .parse_type_param_def();
-        types.push(bd.space, bd);
+        generics.types.push(bd.space, bd);
     }
 
-    let mut regions = subst::VecPerParamSpace::empty();
     for p in reader::tagged_docs(doc, tag_region_param_def) {
         let bd =
             TyDecoder::with_doc(tcx, cdata.cnum, p,
                                 &mut |did| translate_def_id(cdata, did))
             .parse_region_param_def();
-        regions.push(bd.space, bd);
+        generics.regions.push(bd.space, bd);
     }
 
-    ty::Generics { types: types, regions: regions }
+    generics
 }
 
 fn doc_predicate<'a, 'tcx>(cdata: Cmd,

src/librustc_mir/build/scope.rs

@@ -89,7 +89,7 @@ should go to.
 use build::{BlockAnd, BlockAndExtension, Builder, CFG, ScopeAuxiliary, ScopeId};
 use rustc::middle::region::{CodeExtent, CodeExtentData};
 use rustc::middle::lang_items;
-use rustc::ty::subst::{Substs, Subst, VecPerParamSpace};
+use rustc::ty::subst::{Substs, Subst};
 use rustc::ty::{Ty, TyCtxt};
 use rustc::mir::repr::*;
 use syntax_pos::Span;
@@ -750,10 +750,7 @@ fn build_free<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
                               -> TerminatorKind<'tcx> {
     let free_func = tcx.lang_items.require(lang_items::BoxFreeFnLangItem)
                        .unwrap_or_else(|e| tcx.sess.fatal(&e));
-    let substs = tcx.mk_substs(Substs::new(
-        VecPerParamSpace::new(vec![], vec![], vec![data.item_ty]),
-        VecPerParamSpace::new(vec![], vec![], vec![])
-    ));
+    let substs = tcx.mk_substs(Substs::new_fn(vec![data.item_ty], vec![]));
     TerminatorKind::Call {
         func: Operand::Constant(Constant {
             span: data.span,

src/librustc_trans/base.rs

@@ -39,7 +39,7 @@ use rustc::cfg;
 use rustc::hir::def_id::DefId;
 use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem};
 use rustc::hir::pat_util::simple_name;
-use rustc::ty::subst::{self, Substs};
+use rustc::ty::subst::Substs;
 use rustc::traits;
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc::ty::adjustment::CustomCoerceUnsized;
@@ -675,10 +675,7 @@ pub fn custom_coerce_unsize_info<'scx, 'tcx>(scx: &SharedCrateContext<'scx, 'tcx
                                              source_ty: Ty<'tcx>,
                                              target_ty: Ty<'tcx>)
                                              -> CustomCoerceUnsized {
-    let trait_substs = Substs::new(subst::VecPerParamSpace::new(vec![source_ty],
-                                                                vec![target_ty],
-                                                                Vec::new()),
-                                   subst::VecPerParamSpace::empty());
+    let trait_substs = Substs::new_trait(vec![target_ty], vec![], source_ty);
 
     let trait_ref = ty::Binder(ty::TraitRef {
         def_id: scx.tcx().lang_items.coerce_unsized_trait().unwrap(),

src/librustc_typeck/check/mod.rs

@@ -2796,9 +2796,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         debug!("impl_self_ty: tps={:?} rps={:?} raw_ty={:?}", tps, rps, raw_ty);
 
         let rps = self.region_vars_for_defs(span, rps);
-        let mut substs = subst::Substs::new(
-            VecPerParamSpace::empty(),
-            VecPerParamSpace::new(Vec::new(), rps, Vec::new()));
+        let mut substs = subst::Substs::new_type(vec![], rps);
         self.type_vars_for_defs(span, ParamSpace::TypeSpace, &mut substs, tps);
         let substd_ty = self.instantiate_type_scheme(span, &substs, &raw_ty);
 

src/librustc_typeck/variance/solve.rs

@@ -15,7 +15,6 @@
 //! optimal solution to the constraints. The final variance for each
 //! inferred is then written into the `variance_map` in the tcx.
 
-use rustc::ty::subst::VecPerParamSpace;
 use rustc::ty;
 use std::rc::Rc;
 
@@ -109,26 +108,21 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> {
         let num_inferred = self.terms_cx.num_inferred();
         while index < num_inferred {
             let item_id = inferred_infos[index].item_id;
-            let mut types = VecPerParamSpace::empty();
-            let mut regions = VecPerParamSpace::empty();
+            let mut item_variances = ty::ItemVariances::empty();
 
             while index < num_inferred && inferred_infos[index].item_id == item_id {
                 let info = &inferred_infos[index];
                 let variance = solutions[index];
                 debug!("Index {} Info {} / {:?} / {:?} Variance {:?}",
                        index, info.index, info.kind, info.space, variance);
                 match info.kind {
-                    TypeParam => { types.push(info.space, variance); }
-                    RegionParam => { regions.push(info.space, variance); }
+                    TypeParam => { item_variances.types.push(info.space, variance); }
+                    RegionParam => { item_variances.regions.push(info.space, variance); }
                 }
 
                 index += 1;
             }
 
-            let item_variances = ty::ItemVariances {
-                types: types,
-                regions: regions
-            };
             debug!("item_id={} item_variances={:?}",
                     item_id,
                     item_variances);

src/librustc_typeck/variance/terms.rs

@@ -21,7 +21,7 @@
 
 use arena::TypedArena;
 use dep_graph::DepTrackingMapConfig;
-use rustc::ty::subst::{ParamSpace, FnSpace, TypeSpace, SelfSpace, VecPerParamSpace};
+use rustc::ty::subst::{ParamSpace, FnSpace, TypeSpace, SelfSpace};
 use rustc::ty::{self, TyCtxt};
 use rustc::ty::maps::ItemVariances;
 use std::fmt;
@@ -112,10 +112,7 @@ pub fn determine_parameters_to_be_inferred<'a, 'tcx>(
 
         // cache and share the variance struct used for items with
         // no type/region parameters
-        empty_variances: Rc::new(ty::ItemVariances {
-            types: VecPerParamSpace::empty(),
-            regions: VecPerParamSpace::empty()
-        })
+        empty_variances: Rc::new(ty::ItemVariances::empty())
     };
 
     // See README.md for a discussion on dep-graph management.