Auto merge of #156134 - jhpratt:rollup-79KaBC4, r=jhpratt

bors · bors · commit 1d72d7e8136f · 2026-05-04T09:31:36.000Z
Rollup of 3 pull requests Successful merges: - #156120 (Regression test for trait-system-refactor#7) - #156125 (refactor using ExprParenthesesNeeded where possible) - #156132 (More lifting tweaks)
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -21,6 +21,7 @@ use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::{self, IsSuggestable, Ty, TyCtxt, TypeVisitableExt, Unnormalized};
 use rustc_middle::{bug, span_bug};
 use rustc_session::Session;
+use rustc_session::errors::ExprParenthesesNeeded;
 use rustc_span::{DUMMY_SP, Ident, Span, kw, sym};
 use rustc_trait_selection::error_reporting::infer::{FailureCode, ObligationCauseExt};
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -954,14 +955,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         // wrapping in parentheses. We find the statement or expression
                         // following the `match` (`&& true`) and see if it is something that
                         // can reasonably be interpreted as a binop following an expression.
-                        err.multipart_suggestion(
-                            "parentheses are required to parse this as an expression",
-                            vec![
-                                (expr.span.shrink_to_lo(), "(".to_string()),
-                                (expr.span.shrink_to_hi(), ")".to_string()),
-                            ],
-                            Applicability::MachineApplicable,
-                        );
+                        err.subdiagnostic(ExprParenthesesNeeded::surrounding(expr.span));
                     } else if expr.can_have_side_effects() {
                         self.suggest_semicolon_at_end(expr.span, err);
                     }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -799,14 +799,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     && let hir::StmtKind::Expr(_) = stmt.kind
                     && self.is_next_stmt_expr_continuation(stmt.hir_id)
                 {
-                    err.multipart_suggestion(
-                        "parentheses are required to parse this as an expression",
-                        vec![
-                            (stmt.span.shrink_to_lo(), "(".to_string()),
-                            (stmt.span.shrink_to_hi(), ")".to_string()),
-                        ],
-                        Applicability::MachineApplicable,
-                    );
+                    err.subdiagnostic(ExprParenthesesNeeded::surrounding(stmt.span));
                 } else {
                     err.span_suggestion(
                         expression.span.shrink_to_hi(),
@@ -843,14 +836,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // wrapping in parentheses. We find the statement or expression following the
                     // `if` (`&& true`) and see if it is something that can reasonably be
                     // interpreted as a binop following an expression.
-                    err.multipart_suggestion(
-                        "parentheses are required to parse this as an expression",
-                        vec![
-                            (stmt.span.shrink_to_lo(), "(".to_string()),
-                            (stmt.span.shrink_to_hi(), ")".to_string()),
-                        ],
-                        Applicability::MachineApplicable,
-                    );
+                    err.subdiagnostic(ExprParenthesesNeeded::surrounding(stmt.span));
                 }
             }
         }
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -22,7 +22,7 @@ use crate::ty::{
 impl IntoDiagArg for Ty<'_> {
     fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         ty::tls::with(|tcx| {
-            let ty = tcx.short_string(self, path);
+            let ty = tcx.short_string(tcx.lift(self), path);
             DiagArgValue::Str(std::borrow::Cow::Owned(ty))
         })
     }
@@ -31,7 +31,7 @@ impl IntoDiagArg for Ty<'_> {
 impl IntoDiagArg for Instance<'_> {
     fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         ty::tls::with(|tcx| {
-            let instance = tcx.short_string_namespace(self, path, Namespace::ValueNS);
+            let instance = tcx.short_string_namespace(tcx.lift(self), path, Namespace::ValueNS);
             DiagArgValue::Str(std::borrow::Cow::Owned(instance))
         })
     }
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
@@ -12,7 +12,7 @@ use rustc_macros::extension;
 pub use rustc_type_ir::error::ExpectedFound;
 
 use crate::ty::print::{FmtPrinter, Print, with_forced_trimmed_paths};
-use crate::ty::{self, Lift, Ty, TyCtxt};
+use crate::ty::{self, Ty, TyCtxt};
 
 pub type TypeError<'tcx> = rustc_type_ir::error::TypeError<TyCtxt<'tcx>>;
 
@@ -220,10 +220,10 @@ impl<'tcx> Ty<'tcx> {
 impl<'tcx> TyCtxt<'tcx> {
     pub fn string_with_limit<T>(self, t: T, length_limit: usize, ns: hir::def::Namespace) -> String
     where
-        T: Copy + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
+        T: Copy + for<'a> Print<FmtPrinter<'a, 'tcx>>,
     {
         let mut type_limit = 50;
-        let regular = FmtPrinter::print_string(self, ns, |p| self.lift(t).print(p))
+        let regular = FmtPrinter::print_string(self, ns, |p| t.print(p))
             .expect("could not write to `String`");
         if regular.len() <= length_limit {
             return regular;
@@ -233,7 +233,7 @@ impl<'tcx> TyCtxt<'tcx> {
             // Look for the longest properly trimmed path that still fits in length_limit.
             short = with_forced_trimmed_paths!({
                 let mut p = FmtPrinter::new_with_limit(self, ns, Limit(type_limit));
-                self.lift(t).print(&mut p).expect("could not print type");
+                t.print(&mut p).expect("could not print type");
                 p.into_buffer()
             });
             if short.len() <= length_limit || type_limit == 0 {
@@ -250,7 +250,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// where we wrote the file to is only printed once. The path will use the type namespace.
     pub fn short_string<T>(self, t: T, path: &mut Option<PathBuf>) -> String
     where
-        T: Copy + Hash + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
+        T: Copy + Hash + for<'a> Print<FmtPrinter<'a, 'tcx>>,
     {
         self.short_string_namespace(t, path, hir::def::Namespace::TypeNS)
     }
@@ -266,9 +266,9 @@ impl<'tcx> TyCtxt<'tcx> {
         namespace: hir::def::Namespace,
     ) -> String
     where
-        T: Copy + Hash + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
+        T: Copy + Hash + for<'a> Print<FmtPrinter<'a, 'tcx>>,
     {
-        let regular = FmtPrinter::print_string(self, namespace, |p| self.lift(t).print(p))
+        let regular = FmtPrinter::print_string(self, namespace, |p| t.print(p))
             .expect("could not write to `String`");
 
         if !self.sess.opts.unstable_opts.write_long_types_to_disk || self.sess.opts.verbose {
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
@@ -113,7 +113,7 @@ impl<'tcx> Predicate<'tcx> {
 impl<'tcx> rustc_errors::IntoDiagArg for Predicate<'tcx> {
     fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         ty::tls::with(|tcx| {
-            let pred = tcx.short_string(self, path);
+            let pred = tcx.short_string(tcx.lift(self), path);
             rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(pred))
         })
     }
@@ -122,7 +122,7 @@ impl<'tcx> rustc_errors::IntoDiagArg for Predicate<'tcx> {
 impl<'tcx> rustc_errors::IntoDiagArg for Clause<'tcx> {
     fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         ty::tls::with(|tcx| {
-            let clause = tcx.short_string(self, path);
+            let clause = tcx.short_string(tcx.lift(self), path);
             rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(clause))
         })
     }
diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -15,7 +15,7 @@ use super::Lift;
 
 pub type PrintError = std::fmt::Error;
 
-pub trait Print<'tcx, P> {
+pub trait Print<P> {
     fn print(&self, p: &mut P) -> Result<(), PrintError>;
 }
 
@@ -350,19 +350,19 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
     characteristic_def_id_of_type_cached(ty, &mut SsoHashSet::new())
 }
 
-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Region<'tcx> {
+impl<'tcx, P: Printer<'tcx>> Print<P> for ty::Region<'tcx> {
     fn print(&self, p: &mut P) -> Result<(), PrintError> {
         p.print_region(*self)
     }
 }
 
-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for Ty<'tcx> {
+impl<'tcx, P: Printer<'tcx>> Print<P> for Ty<'tcx> {
     fn print(&self, p: &mut P) -> Result<(), PrintError> {
         p.print_type(*self)
     }
 }
 
-impl<'tcx, P: Printer<'tcx> + std::fmt::Write> Print<'tcx, P> for ty::Instance<'tcx> {
+impl<'tcx, P: Printer<'tcx> + std::fmt::Write> Print<P> for ty::Instance<'tcx> {
     fn print(&self, cx: &mut P) -> Result<(), PrintError> {
         cx.print_def_path(self.def_id(), self.args)?;
         match self.def {
@@ -399,21 +399,21 @@ impl<'tcx, P: Printer<'tcx> + std::fmt::Write> Print<'tcx, P> for ty::Instance<'
     }
 }
 
-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> {
+impl<'tcx, P: Printer<'tcx>> Print<P> for &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> {
     fn print(&self, p: &mut P) -> Result<(), PrintError> {
         p.print_dyn_existential(self)
     }
 }
 
-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Const<'tcx> {
+impl<'tcx, P: Printer<'tcx>> Print<P> for ty::Const<'tcx> {
     fn print(&self, p: &mut P) -> Result<(), PrintError> {
         p.print_const(*self)
     }
 }
 
 impl<T> rustc_type_ir::ir_print::IrPrint<T> for TyCtxt<'_>
 where
-    T: Copy + for<'a, 'tcx> Lift<TyCtxt<'tcx>, Lifted: Print<'tcx, FmtPrinter<'a, 'tcx>>>,
+    T: Copy + for<'a, 'tcx> Lift<TyCtxt<'tcx>, Lifted: Print<FmtPrinter<'a, 'tcx>>>,
 {
     fn print(t: &T, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ty::tls::with(|tcx| {
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -265,7 +265,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
 
     fn pretty_print_in_binder<T>(&mut self, value: &ty::Binder<'tcx, T>) -> Result<(), PrintError>
     where
-        T: Print<'tcx, Self> + TypeFoldable<TyCtxt<'tcx>>,
+        T: Print<Self> + TypeFoldable<TyCtxt<'tcx>>,
     {
         value.as_ref().skip_binder().print(self)
     }
@@ -285,7 +285,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
     /// Prints comma-separated elements.
     fn comma_sep<T>(&mut self, mut elems: impl Iterator<Item = T>) -> Result<(), PrintError>
     where
-        T: Print<'tcx, Self>,
+        T: Print<Self>,
     {
         if let Some(first) = elems.next() {
             first.print(self)?;
@@ -2484,7 +2484,7 @@ impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {
 
     fn pretty_print_in_binder<T>(&mut self, value: &ty::Binder<'tcx, T>) -> Result<(), PrintError>
     where
-        T: Print<'tcx, Self> + TypeFoldable<TyCtxt<'tcx>>,
+        T: Print<Self> + TypeFoldable<TyCtxt<'tcx>>,
     {
         self.wrap_binder(value, WrapBinderMode::ForAll, |new_value, this| new_value.print(this))
     }
@@ -2940,18 +2940,18 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
     }
 }
 
-impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::Binder<'tcx, T>
+impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<P> for ty::Binder<'tcx, T>
 where
-    T: Print<'tcx, P> + TypeFoldable<TyCtxt<'tcx>>,
+    T: Print<P> + TypeFoldable<TyCtxt<'tcx>>,
 {
     fn print(&self, p: &mut P) -> Result<(), PrintError> {
         p.pretty_print_in_binder(self)
     }
 }
 
-impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::OutlivesPredicate<'tcx, T>
+impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<P> for ty::OutlivesPredicate<'tcx, T>
 where
-    T: Print<'tcx, P>,
+    T: Print<P>,
 {
     fn print(&self, p: &mut P) -> Result<(), PrintError> {
         self.0.print(p)?;
@@ -2970,7 +2970,7 @@ pub struct TraitRefPrintOnlyTraitPath<'tcx>(ty::TraitRef<'tcx>);
 impl<'tcx> rustc_errors::IntoDiagArg for TraitRefPrintOnlyTraitPath<'tcx> {
     fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         ty::tls::with(|tcx| {
-            let trait_ref = tcx.short_string(self, path);
+            let trait_ref = tcx.short_string(tcx.lift(self), path);
             rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(trait_ref))
         })
     }
@@ -2990,7 +2990,7 @@ pub struct TraitRefPrintSugared<'tcx>(ty::TraitRef<'tcx>);
 impl<'tcx> rustc_errors::IntoDiagArg for TraitRefPrintSugared<'tcx> {
     fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         ty::tls::with(|tcx| {
-            let trait_ref = tcx.short_string(self, path);
+            let trait_ref = tcx.short_string(tcx.lift(self), path);
             rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(trait_ref))
         })
     }
@@ -3108,7 +3108,7 @@ macro_rules! forward_display_to_print {
 
 macro_rules! define_print {
     (($self:ident, $p:ident): $($ty:ty $print:block)+) => {
-        $(impl<'tcx, P: PrettyPrinter<'tcx>> Print<'tcx, P> for $ty {
+        $(impl<'tcx, P: PrettyPrinter<'tcx>> Print<P> for $ty {
             fn print(&$self, $p: &mut P) -> Result<(), PrintError> {
                 let _: () = $print;
                 Ok(())
diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs
@@ -480,7 +480,7 @@ impl<'tcx> PrettyPrinter<'tcx> for LegacySymbolMangler<'tcx> {
     // Identical to `PrettyPrinter::comma_sep` except there is no space after each comma.
     fn comma_sep<T>(&mut self, mut elems: impl Iterator<Item = T>) -> Result<(), PrintError>
     where
-        T: Print<'tcx, Self>,
+        T: Print<Self>,
     {
         if let Some(first) = elems.next() {
             first.print(self)?;
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs
@@ -28,7 +28,7 @@ pub(crate) struct Highlighted<'tcx, T> {
 
 impl<'tcx, T> IntoDiagArg for Highlighted<'tcx, T>
 where
-    T: for<'a> Print<'tcx, FmtPrinter<'a, 'tcx>>,
+    T: for<'a> Print<FmtPrinter<'a, 'tcx>>,
 {
     fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         rustc_errors::DiagArgValue::Str(self.to_string().into())
@@ -43,7 +43,7 @@ impl<'tcx, T> Highlighted<'tcx, T> {
 
 impl<'tcx, T> fmt::Display for Highlighted<'tcx, T>
 where
-    T: for<'a> Print<'tcx, FmtPrinter<'a, 'tcx>>,
+    T: for<'a> Print<FmtPrinter<'a, 'tcx>>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut p = ty::print::FmtPrinter::new(self.tcx, self.ns);
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
@@ -60,7 +60,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
     ) -> Diag<'a> {
         fn with_short_path<'tcx, T>(tcx: TyCtxt<'tcx>, value: T) -> String
         where
-            T: fmt::Display + Print<'tcx, FmtPrinter<'tcx, 'tcx>>,
+            T: fmt::Display + for<'b> Print<FmtPrinter<'b, 'tcx>>,
         {
             let s = value.to_string();
             if s.len() > 50 {
diff --git a/tests/ui/traits/next-solver/alias-relate/transitive-inference.rs b/tests/ui/traits/next-solver/alias-relate/transitive-inference.rs
@@ -0,0 +1,42 @@
+//@ revisions: old next
+//@[next] compile-flags: -Znext-solver=globally
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+// Regression test for trait-system-refactor-initiative#7. This test
+// would error if we were to rely on lazy normalization here.
+//
+// We eagerly normalize the associated types, here, causing this to
+// compile.
+
+use std::marker::PhantomData;
+
+#[derive(Default)]
+struct Foo<T, U>(PhantomData<(T, U)>);
+
+trait Trait {
+    type Assoc;
+
+    fn to_assoc(self) -> Self::Assoc;
+}
+
+impl Trait for Foo<u32, i32> {
+    type Assoc = Foo<u32, i32>;
+    fn to_assoc(self) -> Self::Assoc {
+        Foo(PhantomData)
+    }
+}
+impl Trait for Foo<i32, u32> {
+    type Assoc = Foo<i32, u32>;
+    fn to_assoc(self) -> Self::Assoc {
+        Foo(PhantomData)
+    }
+}
+
+#[allow(unused_assignments)]
+fn main() {
+    let mut x: Foo<_, _> = Default::default();
+    let mut assoc = x.to_assoc();
+    assoc = Foo::<u32, _>(PhantomData);
+    assoc = Foo::<_, i32>(PhantomData);
+    x = assoc;
+}

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ use super::Lift;`
`15`	`15`
`16`	`16`	`pub type PrintError = std::fmt::Error;`
`17`	`17`
`18`		`-pub trait Print<'tcx, P> {`
	`18`	`+pub trait Print<P> {`
`19`	`19`	`fn print(&self, p: &mut P) -> Result<(), PrintError>;`
`20`	`20`	`}`
`21`	`21`
`@@ -350,19 +350,19 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {`
`350`	`350`	`characteristic_def_id_of_type_cached(ty, &mut SsoHashSet::new())`
`351`	`351`	`}`
`352`	`352`
`353`		`-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Region<'tcx> {`
	`353`	`+impl<'tcx, P: Printer<'tcx>> Print<P> for ty::Region<'tcx> {`
`354`	`354`	`fn print(&self, p: &mut P) -> Result<(), PrintError> {`
`355`	`355`	`p.print_region(*self)`
`356`	`356`	`}`
`357`	`357`	`}`
`358`	`358`
`359`		`-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for Ty<'tcx> {`
	`359`	`+impl<'tcx, P: Printer<'tcx>> Print<P> for Ty<'tcx> {`
`360`	`360`	`fn print(&self, p: &mut P) -> Result<(), PrintError> {`
`361`	`361`	`p.print_type(*self)`
`362`	`362`	`}`
`363`	`363`	`}`
`364`	`364`
`365`		`-impl<'tcx, P: Printer<'tcx> + std::fmt::Write> Print<'tcx, P> for ty::Instance<'tcx> {`
	`365`	`+impl<'tcx, P: Printer<'tcx> + std::fmt::Write> Print<P> for ty::Instance<'tcx> {`
`366`	`366`	`fn print(&self, cx: &mut P) -> Result<(), PrintError> {`
`367`	`367`	`cx.print_def_path(self.def_id(), self.args)?;`
`368`	`368`	`match self.def {`
`@@ -399,21 +399,21 @@ impl<'tcx, P: Printer<'tcx> + std::fmt::Write> Print<'tcx, P> for ty::Instance<'`
`399`	`399`	`}`
`400`	`400`	`}`
`401`	`401`
`402`		`-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> {`
	`402`	`+impl<'tcx, P: Printer<'tcx>> Print<P> for &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> {`
`403`	`403`	`fn print(&self, p: &mut P) -> Result<(), PrintError> {`
`404`	`404`	`p.print_dyn_existential(self)`
`405`	`405`	`}`
`406`	`406`	`}`
`407`	`407`
`408`		`-impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Const<'tcx> {`
	`408`	`+impl<'tcx, P: Printer<'tcx>> Print<P> for ty::Const<'tcx> {`
`409`	`409`	`fn print(&self, p: &mut P) -> Result<(), PrintError> {`
`410`	`410`	`p.print_const(*self)`
`411`	`411`	`}`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`impl<T> rustc_type_ir::ir_print::IrPrint<T> for TyCtxt<'_>`
`415`	`415`	`where`
`416`		`- T: Copy + for<'a, 'tcx> Lift<TyCtxt<'tcx>, Lifted: Print<'tcx, FmtPrinter<'a, 'tcx>>>,`
	`416`	`+ T: Copy + for<'a, 'tcx> Lift<TyCtxt<'tcx>, Lifted: Print<FmtPrinter<'a, 'tcx>>>,`
`417`	`417`	`{`
`418`	`418`	`fn print(t: &T, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`419`	`419`	`ty::tls::with(\|tcx\| {`
Original file line number	Diff line number	Diff line change
`@@ -265,7 +265,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {`
`265`	`265`
`266`	`266`	`fn pretty_print_in_binder<T>(&mut self, value: &ty::Binder<'tcx, T>) -> Result<(), PrintError>`
`267`	`267`	`where`
`268`		`- T: Print<'tcx, Self> + TypeFoldable<TyCtxt<'tcx>>,`
	`268`	`+ T: Print<Self> + TypeFoldable<TyCtxt<'tcx>>,`
`269`	`269`	`{`
`270`	`270`	`value.as_ref().skip_binder().print(self)`
`271`	`271`	`}`
`@@ -285,7 +285,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {`
`285`	`285`	`/// Prints comma-separated elements.`
`286`	`286`	`fn comma_sep<T>(&mut self, mut elems: impl Iterator<Item = T>) -> Result<(), PrintError>`
`287`	`287`	`where`
`288`		`- T: Print<'tcx, Self>,`
	`288`	`+ T: Print<Self>,`
`289`	`289`	`{`
`290`	`290`	`if let Some(first) = elems.next() {`
`291`	`291`	`first.print(self)?;`
`@@ -2484,7 +2484,7 @@ impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {`
`2484`	`2484`
`2485`	`2485`	`fn pretty_print_in_binder<T>(&mut self, value: &ty::Binder<'tcx, T>) -> Result<(), PrintError>`
`2486`	`2486`	`where`
`2487`		`- T: Print<'tcx, Self> + TypeFoldable<TyCtxt<'tcx>>,`
	`2487`	`+ T: Print<Self> + TypeFoldable<TyCtxt<'tcx>>,`
`2488`	`2488`	`{`
`2489`	`2489`	`self.wrap_binder(value, WrapBinderMode::ForAll, \|new_value, this\| new_value.print(this))`
`2490`	`2490`	`}`
`@@ -2940,18 +2940,18 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {`
`2940`	`2940`	`}`
`2941`	`2941`	`}`
`2942`	`2942`
`2943`		`-impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::Binder<'tcx, T>`
	`2943`	`+impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<P> for ty::Binder<'tcx, T>`
`2944`	`2944`	`where`
`2945`		`- T: Print<'tcx, P> + TypeFoldable<TyCtxt<'tcx>>,`
	`2945`	`+ T: Print<P> + TypeFoldable<TyCtxt<'tcx>>,`
`2946`	`2946`	`{`
`2947`	`2947`	`fn print(&self, p: &mut P) -> Result<(), PrintError> {`
`2948`	`2948`	`p.pretty_print_in_binder(self)`
`2949`	`2949`	`}`
`2950`	`2950`	`}`
`2951`	`2951`
`2952`		`-impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::OutlivesPredicate<'tcx, T>`
	`2952`	`+impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<P> for ty::OutlivesPredicate<'tcx, T>`
`2953`	`2953`	`where`
`2954`		`- T: Print<'tcx, P>,`
	`2954`	`+ T: Print<P>,`
`2955`	`2955`	`{`
`2956`	`2956`	`fn print(&self, p: &mut P) -> Result<(), PrintError> {`
`2957`	`2957`	`self.0.print(p)?;`
`@@ -2970,7 +2970,7 @@ pub struct TraitRefPrintOnlyTraitPath<'tcx>(ty::TraitRef<'tcx>);`
`2970`	`2970`	`impl<'tcx> rustc_errors::IntoDiagArg for TraitRefPrintOnlyTraitPath<'tcx> {`
`2971`	`2971`	`fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {`
`2972`	`2972`	`ty::tls::with(\|tcx\| {`
`2973`		`- let trait_ref = tcx.short_string(self, path);`
	`2973`	`+ let trait_ref = tcx.short_string(tcx.lift(self), path);`
`2974`	`2974`	`rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(trait_ref))`
`2975`	`2975`	`})`
`2976`	`2976`	`}`
`@@ -2990,7 +2990,7 @@ pub struct TraitRefPrintSugared<'tcx>(ty::TraitRef<'tcx>);`
`2990`	`2990`	`impl<'tcx> rustc_errors::IntoDiagArg for TraitRefPrintSugared<'tcx> {`
`2991`	`2991`	`fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {`
`2992`	`2992`	`ty::tls::with(\|tcx\| {`
`2993`		`- let trait_ref = tcx.short_string(self, path);`
	`2993`	`+ let trait_ref = tcx.short_string(tcx.lift(self), path);`
`2994`	`2994`	`rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(trait_ref))`
`2995`	`2995`	`})`
`2996`	`2996`	`}`
`@@ -3108,7 +3108,7 @@ macro_rules! forward_display_to_print {`
`3108`	`3108`
`3109`	`3109`	`macro_rules! define_print {`
`3110`	`3110`	`(($self:ident, $p:ident): $($ty:ty $print:block)+) => {`
`3111`		`- $(impl<'tcx, P: PrettyPrinter<'tcx>> Print<'tcx, P> for $ty {`
	`3111`	`+ $(impl<'tcx, P: PrettyPrinter<'tcx>> Print<P> for $ty {`
`3112`	`3112`	`fn print(&$self, $p: &mut P) -> Result<(), PrintError> {`
`3113`	`3113`	`let _: () = $print;`
`3114`	`3114`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -480,7 +480,7 @@ impl<'tcx> PrettyPrinter<'tcx> for LegacySymbolMangler<'tcx> {`
`480`	`480`	// Identical to `PrettyPrinter::comma_sep` except there is no space after each comma.
`481`	`481`	`fn comma_sep<T>(&mut self, mut elems: impl Iterator<Item = T>) -> Result<(), PrintError>`
`482`	`482`	`where`
`483`		`- T: Print<'tcx, Self>,`
	`483`	`+ T: Print<Self>,`
`484`	`484`	`{`
`485`	`485`	`if let Some(first) = elems.next() {`
`486`	`486`	`first.print(self)?;`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {`
`60`	`60`	`) -> Diag<'a> {`
`61`	`61`	`fn with_short_path<'tcx, T>(tcx: TyCtxt<'tcx>, value: T) -> String`
`62`	`62`	`where`
`63`		`- T: fmt::Display + Print<'tcx, FmtPrinter<'tcx, 'tcx>>,`
	`63`	`+ T: fmt::Display + for<'b> Print<FmtPrinter<'b, 'tcx>>,`
`64`	`64`	`{`
`65`	`65`	`let s = value.to_string();`
`66`	`66`	`if s.len() > 50 {`