purge Kind slice with SubstsRef

Author: csmoe

src/librustc/ich/impls_ty.rs

@@ -54,6 +54,19 @@ impl<'a, 'gcx, T> ToStableHashKey<StableHashingContext<'a>> for &'gcx ty::List<T
     }
 }
 
+impl<'a, 'tcx> ToStableHashKey<StableHashingContext<'a>> for ty::subst::SubstsRef<'tcx>
+{
+    type KeyType = <&'tcx ty::List<ty::subst::Kind<'tcx>> as ToStableHashKey<StableHashingContext<'a>>>::KeyType;
+
+    #[inline]
+    fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> Self::KeyType {
+        let mut hasher = StableHasher::new();
+        let mut hcx: StableHashingContext<'a> = hcx.clone();
+        self.hash_stable(&mut hcx, &mut hasher);
+        hasher.finish()
+    }
+}
+
 impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::subst::Kind<'gcx> {
     fn hash_stable<W: StableHasherResult>(&self,
                                           hcx: &mut StableHashingContext<'a>,

src/librustc/infer/error_reporting/mod.rs

@@ -535,7 +535,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             if !(did1.is_local() || did2.is_local()) && did1.krate != did2.krate {
                 let abs_path = |def_id| {
                     AbsolutePathPrinter { tcx: self.tcx }
-                        .print_def_path(def_id, &[])
+                        .print_def_path(def_id, SubstsRef::empty())
                 };
 
                 // We compare strings because DefPath can be different
@@ -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/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/lint/context.rs

@@ -25,7 +25,7 @@ use crate::lint::levels::{LintLevelSets, LintLevelsBuilder};
 use crate::middle::privacy::AccessLevels;
 use crate::rustc_serialize::{Decoder, Decodable, Encoder, Encodable};
 use crate::session::{config, early_error, Session};
-use crate::ty::{self, print::Printer, subst::Kind, TyCtxt, Ty};
+use crate::ty::{self, print::Printer, subst::{Kind, SubstsRef}, TyCtxt, Ty};
 use crate::ty::layout::{LayoutError, LayoutOf, TyLayout};
 use crate::util::nodemap::FxHashMap;
 use crate::util::common::time;
@@ -822,7 +822,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {
                 ) -> Result<Self::Path, Self::Error> {
                 if trait_ref.is_none() {
                     if let ty::Adt(def, substs) = self_ty.sty {
-                        return self.print_def_path(def.did, &substs);
+                        return self.print_def_path(def.did, substs);
                     }
                 }
 
@@ -880,7 +880,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {
         }
 
         AbsolutePathPrinter { tcx: self.tcx }
-            .print_def_path(def_id, &[])
+            .print_def_path(def_id, SubstsRef::empty())
             .unwrap()
     }
 }

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/auto_trait.rs

@@ -89,7 +89,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
 
         let trait_ref = ty::TraitRef {
             def_id: trait_did,
-            substs: tcx.mk_substs_trait(ty, &[]),
+            substs: tcx.mk_substs_trait(ty, SubstsRef::empty()),
         };
 
         let trait_pred = ty::Binder::bind(trait_ref);
@@ -306,7 +306,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
         predicates.push_back(ty::Binder::bind(ty::TraitPredicate {
             trait_ref: ty::TraitRef {
                 def_id: trait_did,
-                substs: infcx.tcx.mk_substs_trait(ty, &[]),
+                substs: infcx.tcx.mk_substs_trait(ty, SubstsRef::empty()),
             },
         }));
 

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,8 +98,8 @@ 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),
+        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,
     };
 

src/librustc/traits/engine.rs

@@ -1,5 +1,6 @@
 use crate::infer::InferCtxt;
 use crate::ty::{self, Ty, TyCtxt, ToPredicate};
+use crate::ty::subst::SubstsRef;
 use crate::traits::Obligation;
 use crate::hir::def_id::DefId;
 
@@ -28,7 +29,7 @@ pub trait TraitEngine<'tcx>: 'tcx {
     ) {
         let trait_ref = ty::TraitRef {
             def_id,
-            substs: infcx.tcx.mk_substs_trait(ty, &[]),
+            substs: infcx.tcx.mk_substs_trait(ty, SubstsRef::empty()),
         };
         self.register_predicate_obligation(infcx, Obligation {
             cause,