rustc: tie the 'tcx between Print and PrintCx in ty::print.

Author: eddyb

src/librustc/infer/outlives/free_region_map.rs

@@ -91,7 +91,7 @@ impl_stable_hash_for!(struct FreeRegionMap<'tcx> {
 impl<'a, 'tcx> Lift<'tcx> for FreeRegionMap<'a> {
     type Lifted = FreeRegionMap<'tcx>;
     fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<FreeRegionMap<'tcx>> {
-        self.relation.maybe_map(|&fr| fr.lift_to_tcx(tcx))
+        self.relation.maybe_map(|&fr| tcx.lift(&fr))
                      .map(|relation| FreeRegionMap { relation })
     }
 }

src/librustc/mir/mod.rs

@@ -2377,7 +2377,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                     AggregateKind::Adt(adt_def, variant, substs, _user_ty, _) => {
                         let variant_def = &adt_def.variants[variant];
 
-                        ppaux::parameterized(fmt, substs, variant_def.did, &[])?;
+                        ppaux::parameterized(fmt, variant_def.did, substs)?;
 
                         match variant_def.ctor_kind {
                             CtorKind::Const => Ok(()),

src/librustc/ty/instance.rs

@@ -174,7 +174,7 @@ impl<'tcx> InstanceDef<'tcx> {
 
 impl<'tcx> fmt::Display for Instance<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        ppaux::parameterized(f, self.substs, self.def_id(), &[])?;
+        ppaux::parameterized(f, self.def_id(), self.substs)?;
         match self.def {
             InstanceDef::Item(_) => Ok(()),
             InstanceDef::VtableShim(_) => {

src/librustc/ty/mod.rs

@@ -973,7 +973,7 @@ impl<'a, 'gcx, 'tcx> Generics {
 }
 
 /// Bounds on generics.
-#[derive(Clone, Default)]
+#[derive(Clone, Default, Debug)]
 pub struct GenericPredicates<'tcx> {
     pub parent: Option<DefId>,
     pub predicates: Vec<(Predicate<'tcx>, Span)>,
@@ -1475,7 +1475,7 @@ impl<'tcx> Predicate<'tcx> {
 /// `[[], [U:Bar<T>]]`.  Now if there were some particular reference
 /// like `Foo<isize,usize>`, then the `InstantiatedPredicates` would be `[[],
 /// [usize:Bar<isize>]]`.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct InstantiatedPredicates<'tcx> {
     pub predicates: Vec<Predicate<'tcx>>,
 }

src/librustc/ty/print.rs

@@ -56,32 +56,36 @@ impl PrintCx<'a, 'gcx, 'tcx> {
 }
 
 pub trait Print<'tcx> {
-    fn print<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintCx<'_, '_, '_>) -> fmt::Result;
-    fn print_to_string(&self, cx: &mut PrintCx<'_, '_, '_>) -> String {
+    fn print<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintCx<'_, '_, 'tcx>) -> fmt::Result;
+    fn print_to_string(&self, cx: &mut PrintCx<'_, '_, 'tcx>) -> String {
         let mut result = String::new();
         let _ = self.print(&mut result, cx);
         result
     }
-    fn print_display<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintCx<'_, '_, '_>) -> fmt::Result {
+    fn print_display<F: fmt::Write>(
+        &self,
+        f: &mut F,
+        cx: &mut PrintCx<'_, '_, 'tcx>,
+    ) -> fmt::Result {
         let old_debug = cx.is_debug;
         cx.is_debug = false;
         let result = self.print(f, cx);
         cx.is_debug = old_debug;
         result
     }
-    fn print_display_to_string(&self, cx: &mut PrintCx<'_, '_, '_>) -> String {
+    fn print_display_to_string(&self, cx: &mut PrintCx<'_, '_, 'tcx>) -> String {
         let mut result = String::new();
         let _ = self.print_display(&mut result, cx);
         result
     }
-    fn print_debug<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintCx<'_, '_, '_>) -> fmt::Result {
+    fn print_debug<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintCx<'_, '_, 'tcx>) -> fmt::Result {
         let old_debug = cx.is_debug;
         cx.is_debug = true;
         let result = self.print(f, cx);
         cx.is_debug = old_debug;
         result
     }
-    fn print_debug_to_string(&self, cx: &mut PrintCx<'_, '_, '_>) -> String {
+    fn print_debug_to_string(&self, cx: &mut PrintCx<'_, '_, 'tcx>) -> String {
         let mut result = String::new();
         let _ = self.print_debug(&mut result, cx);
         result

src/librustc/ty/structural_impls.rs

@@ -47,7 +47,10 @@ CloneTypeFoldableAndLiftImpls! {
     // really meant to be folded. In general, we can only fold a fully
     // general `Region`.
     ::ty::BoundRegion,
+    ::ty::Placeholder<::ty::BoundRegion>,
     ::ty::ClosureKind,
+    ::ty::FreeRegion,
+    ::ty::InferTy,
     ::ty::IntVarValue,
     ::ty::ParamTy,
     ::ty::UniverseIndex,
@@ -472,6 +475,13 @@ impl<'a, 'tcx> Lift<'tcx> for ty::InstanceDef<'a> {
     }
 }
 
+BraceStructLiftImpl! {
+    impl<'a, 'tcx> Lift<'tcx> for ty::TypeAndMut<'a> {
+        type Lifted = ty::TypeAndMut<'tcx>;
+        ty, mutbl
+    }
+}
+
 BraceStructLiftImpl! {
     impl<'a, 'tcx> Lift<'tcx> for ty::Instance<'a> {
         type Lifted = ty::Instance<'tcx>;
@@ -486,6 +496,16 @@ BraceStructLiftImpl! {
     }
 }
 
+// FIXME(eddyb) this is like what `CloneTypeFoldableAndLiftImpls!`
+// generates, except that macro *also* generates a foldable impl,
+// which we don't want (with it we'd risk bypassing `fold_region`).
+impl<'tcx> Lift<'tcx> for ty::RegionKind {
+    type Lifted = ty::RegionKind;
+    fn lift_to_tcx<'b, 'gcx>(&self, _: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
+        Some(self.clone())
+    }
+}
+
 BraceStructLiftImpl! {
     impl<'a, 'tcx> Lift<'tcx> for ty::Const<'a> {
         type Lifted = ty::Const<'tcx>;

src/librustc/ty/sty.rs

@@ -608,7 +608,7 @@ impl<'tcx> List<ExistentialPredicate<'tcx>> {
 
     #[inline]
     pub fn projection_bounds<'a>(&'a self) ->
-        impl Iterator<Item=ExistentialProjection<'tcx>> + 'a {
+        impl Iterator<Item=ExistentialProjection<'tcx>> + Clone + 'a {
         self.iter().filter_map(|predicate| {
             match *predicate {
                 ExistentialPredicate::Projection(p) => Some(p),

src/librustc/ty/subst.rs

@@ -122,8 +122,8 @@ impl<'a, 'tcx> Lift<'tcx> for Kind<'a> {
 
     fn lift_to_tcx<'cx, 'gcx>(&self, tcx: TyCtxt<'cx, 'gcx, 'tcx>) -> Option<Self::Lifted> {
         match self.unpack() {
-            UnpackedKind::Lifetime(a) => a.lift_to_tcx(tcx).map(|a| a.into()),
-            UnpackedKind::Type(a) => a.lift_to_tcx(tcx).map(|a| a.into()),
+            UnpackedKind::Lifetime(a) => tcx.lift(&a).map(|a| a.into()),
+            UnpackedKind::Type(a) => tcx.lift(&a).map(|a| a.into()),
         }
     }
 }