new struct substsref

Author: csmoe

src/librustc/infer/error_reporting/mod.rs

@@ -824,7 +824,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 if !has_default {
                     break;
                 }
-                if self.tcx.type_of(def_id).subst(self.tcx, substs) != actual {
+                if self.tcx.type_of(def_id).subst(self.tcx, &substs) != actual {
                     break;
                 }
                 num_supplied_defaults += 1;

src/librustc/infer/opaque_types/mod.rs

@@ -408,7 +408,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                         substs,
                         item_def_id: _,
                     }) => {
-                        for k in substs {
+                        for k in substs.iter() {
                             match k.unpack() {
                                 UnpackedKind::Lifetime(lt) => bound_region(lt),
                                 UnpackedKind::Type(ty) => types.push(ty),
@@ -653,7 +653,7 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for ReverseMapper<'cx, 'gcx, 'tcx>
                     },
                 ));
 
-                self.tcx.mk_closure(def_id, ty::ClosureSubsts { substs })
+                self.tcx.mk_closure(def_id, ty::ClosureSubsts { substs: substs.into() })
             }
 
             _ => ty.super_fold_with(self),

src/librustc/infer/outlives/obligations.rs

@@ -431,7 +431,7 @@ where
         if approx_env_bounds.is_empty() && trait_bounds.is_empty() && needs_infer {
             debug!("projection_must_outlive: no declared bounds");
 
-            for k in projection_ty.substs {
+            for k in projection_ty.substs.iter() {
                 match k.unpack() {
                     UnpackedKind::Lifetime(lt) => {
                         self.delegate.push_sub_region_constraint(origin.clone(), region, lt);

src/librustc/infer/outlives/verify.rs

@@ -248,7 +248,7 @@ impl<'cx, 'gcx, 'tcx> VerifyBoundCx<'cx, 'gcx, 'tcx> {
         debug!("projection_bounds(projection_ty={:?})", projection_ty);
         let tcx = self.tcx;
         self.region_bounds_declared_on_associated_item(projection_ty.item_def_id)
-            .map(move |r| r.subst(tcx, projection_ty.substs))
+            .map(move |r| r.subst(tcx, &projection_ty.substs))
     }
 
     /// Given the `DefId` of an associated item, returns any region

src/librustc/mir/mod.rs

@@ -2320,7 +2320,7 @@ impl<'tcx> Operand<'tcx> {
         substs: SubstsRef<'tcx>,
         span: Span,
     ) -> Self {
-        let ty = tcx.type_of(def_id).subst(tcx, substs);
+        let ty = tcx.type_of(def_id).subst(tcx, &substs);
         Operand::Constant(box Constant {
             span,
             ty,
@@ -2539,7 +2539,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                         ty::tls::with(|tcx| {
                             let substs = tcx.lift(&substs).expect("could not lift for printing");
                             FmtPrinter::new(tcx, f, Namespace::ValueNS)
-                                .print_def_path(variant_def.def_id, substs)?;
+                                .print_def_path(variant_def.def_id, &substs)?;
                             Ok(())
                         })?;
 

src/librustc/mir/tcx.rs

@@ -195,7 +195,7 @@ impl<'tcx> Rvalue<'tcx> {
                         tcx.mk_tup(ops.iter().map(|op| op.ty(local_decls, tcx)))
                     }
                     AggregateKind::Adt(def, _, substs, _, _) => {
-                        tcx.type_of(def.did).subst(tcx, substs)
+                        tcx.type_of(def.did).subst(tcx, &substs)
                     }
                     AggregateKind::Closure(did, substs) => {
                         tcx.mk_closure(did, substs)

src/librustc/traits/codegen/mod.rs

@@ -96,7 +96,7 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
             value,
             param_env,
         );
-        let substituted = value.subst(self, param_substs);
+        let substituted = value.subst(self, &param_substs);
         self.normalize_erasing_regions(param_env, substituted)
     }
 }

src/librustc/traits/coherence.rs

@@ -98,9 +98,9 @@ fn with_fresh_ty_vars<'cx, 'gcx, 'tcx>(selcx: &mut SelectionContext<'cx, 'gcx, '
 
     let header = ty::ImplHeader {
         impl_def_id,
-        self_ty: tcx.type_of(impl_def_id).subst(tcx, impl_substs),
-        trait_ref: tcx.impl_trait_ref(impl_def_id).subst(tcx, impl_substs),
-        predicates: tcx.predicates_of(impl_def_id).instantiate(tcx, impl_substs).predicates,
+        self_ty: tcx.type_of(impl_def_id).subst(tcx, &impl_substs),
+        trait_ref: tcx.impl_trait_ref(impl_def_id).subst(tcx, &impl_substs),
+        predicates: tcx.predicates_of(impl_def_id).instantiate(tcx, impl_substs.into()).predicates,
     };
 
     let Normalized { value: mut header, obligations } =

src/librustc/traits/error_reporting.rs

@@ -305,7 +305,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 let impl_trait_ref = tcx
                     .impl_trait_ref(def_id)
                     .unwrap()
-                    .subst(tcx, impl_substs);
+                    .subst(tcx, &impl_substs);
 
                 let impl_self_ty = impl_trait_ref.self_ty();
 

src/librustc/traits/object_safety.rs

@@ -415,7 +415,7 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
             }
         });
 
-        let result = receiver_ty.subst(self, substs);
+        let result = receiver_ty.subst(self, &substs);
         debug!("receiver_for_self_ty({:?}, {:?}, {:?}) = {:?}",
                receiver_ty, self_ty, method_def_id, result);
         result