PR-Feedback; fix for printing Region

Jamesbarford · Jamesbarford · commit 7c825ede94c1 · 2026-04-09T15:02:09.000+01:00
diff --git a/compiler/rustc_hir_analysis/src/check/always_applicable.rs b/compiler/rustc_hir_analysis/src/check/always_applicable.rs
@@ -11,9 +11,7 @@ use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
 use rustc_infer::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::span_bug;
 use rustc_middle::ty::util::CheckRegions;
-use rustc_middle::ty::{
-    self, GenericArgsRef, RegionExt, RegionUtilitiesExt, Ty, TyCtxt, TypingMode,
-};
+use rustc_middle::ty::{self, GenericArgsRef, RegionExt, Ty, TyCtxt, TypingMode};
 use rustc_trait_selection::regions::InferCtxtRegionExt;
 use rustc_trait_selection::traits::{self, ObligationCtxt};
 
@@ -266,17 +264,13 @@ fn ensure_impl_predicates_are_implied_by_item_defn<'tcx>(
             let item_span = tcx.def_span(adt_def_id);
             let self_descr = tcx.def_descr(adt_def_id);
             let outlives = match error {
-                RegionResolutionError::ConcreteFailure(_, a, b) => {
-                    format!("{}: {}", b.to_string(), a.to_string())
-                }
+                RegionResolutionError::ConcreteFailure(_, a, b) => format!("{b}: {a}"),
                 RegionResolutionError::GenericBoundFailure(_, generic, r) => {
-                    format!("{generic}: {}", r.to_string())
-                }
-                RegionResolutionError::SubSupConflict(_, _, _, a, _, b, _) => {
-                    format!("{}: {}", b.to_string(), a.to_string())
+                    format!("{generic}: {r}")
                 }
+                RegionResolutionError::SubSupConflict(_, _, _, a, _, b, _) => format!("{b}: {a}"),
                 RegionResolutionError::UpperBoundUniverseConflict(a, _, _, _, b) => {
-                    format!("{}: {}", b.to_string(), ty::Region::new_var(tcx, a).to_string())
+                    format!("{b}: {a}", a = ty::Region::new_var(tcx, a))
                 }
                 RegionResolutionError::CannotNormalize(..) => unreachable!(),
             };
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -916,9 +916,7 @@ impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for RemapHiddenTyRegions<'tcx> {
                 e
             } else {
                 bug!(
-                    "expected to map region {} to early-bound identity region, but got {}",
-                    region.to_string(),
-                    id_region.to_string()
+                    "expected to map region {region} to early-bound identity region, but got {id_region}"
                 );
             }
         } else {
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -406,9 +406,8 @@ fn bounds_from_generic_predicates<'tcx>(
                     && !v.is_empty()
                 {
                     format!(
-                        "{}: {}",
-                        region.to_string(),
-                        v.into_iter().map(|r| r.to_string()).collect::<Vec<_>>().join(" + ")
+                        "{region}: {}",
+                        v.into_iter().map(Region::to_string).collect::<Vec<_>>().join(" + ")
                     )
                 } else {
                     region.to_string()
@@ -454,7 +453,7 @@ fn fn_sig_suggestion<'tcx>(
             Some(match ty.kind() {
                 ty::Param(_) if assoc.is_method() && i == 0 => "self".to_string(),
                 ty::Ref(reg, ref_ty, mutability) if i == 0 => {
-                    let reg = format!("{} ", reg.to_string());
+                    let reg = format!("{reg} ");
                     let reg = match &reg[..] {
                         "'_ " | " " => "",
                         reg => reg,
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -620,7 +620,7 @@ fn gather_gat_bounds<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
             // In our example, requires that `Self: 'a`
             if ty_known_to_outlive(tcx, item_def_id, param_env, wf_tys, *ty, *region_a) {
                 debug!(?ty_idx, ?region_a_idx);
-                debug!("required clause: {ty} must outlive {}", region_a.to_string());
+                debug!("required clause: {ty} must outlive {region_a}");
                 // Translate into the generic parameters of the GAT. In
                 // our example, the type was `Self`, which will also be
                 // `Self` in the GAT.
@@ -655,11 +655,7 @@ fn gather_gat_bounds<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
             }
             if region_known_to_outlive(tcx, item_def_id, param_env, wf_tys, *region_a, *region_b) {
                 debug!(?region_a_idx, ?region_b_idx);
-                debug!(
-                    "required clause: {} must outlive {}",
-                    region_a.to_string(),
-                    region_b.to_string()
-                );
+                debug!("required clause: {region_a} must outlive {region_b}");
                 // Translate into the generic parameters of the GAT.
                 let region_a_param = gat_generics.param_at(*region_a_idx, tcx);
                 let region_a_param = ty::Region::new_early_param(
@@ -2496,10 +2492,7 @@ fn lint_redundant_lifetimes<'tcx>(
                     rustc_lint_defs::builtin::REDUNDANT_LIFETIMES,
                     tcx.local_def_id_to_hir_id(def_id.expect_local()),
                     tcx.def_span(def_id),
-                    RedundantLifetimeArgsLint {
-                        candidate: candidate.diag_arg(),
-                        victim: victim.diag_arg(),
-                    },
+                    RedundantLifetimeArgsLint { candidate, victim },
                 );
             }
         }
@@ -2511,7 +2504,7 @@ fn lint_redundant_lifetimes<'tcx>(
 #[note("you can use the `{$candidate}` lifetime directly, in place of `{$victim}`")]
 struct RedundantLifetimeArgsLint<'tcx> {
     /// The lifetime we have found to be redundant.
-    victim: ty::RegionDiagArg<'tcx>,
+    victim: ty::Region<'tcx>,
     // The lifetime we can replace the victim with.
-    candidate: ty::RegionDiagArg<'tcx>,
+    candidate: ty::Region<'tcx>,
 }
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -14,8 +14,7 @@ use rustc_infer::traits::Obligation;
 use rustc_middle::ty::adjustment::CoerceUnsizedInfo;
 use rustc_middle::ty::print::PrintTraitRefExt as _;
 use rustc_middle::ty::{
-    self, RegionUtilitiesExt, Ty, TyCtxt, TypeVisitableExt, TypingMode,
-    suggest_constraining_type_params,
+    self, Ty, TyCtxt, TypeVisitableExt, TypingMode, suggest_constraining_type_params,
 };
 use rustc_span::{DUMMY_SP, Span, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
@@ -727,7 +726,7 @@ fn infringing_fields_error<'tcx>(
                     let ty = ty.to_string();
                     match error {
                         RegionResolutionError::ConcreteFailure(origin, a, b) => {
-                            let predicate = format!("{}: {}", b.to_string(), a.to_string());
+                            let predicate = format!("{b}: {a}");
                             errors
                                 .entry((ty.clone(), predicate.clone()))
                                 .or_default()
@@ -739,7 +738,7 @@ fn infringing_fields_error<'tcx>(
                             }
                         }
                         RegionResolutionError::GenericBoundFailure(origin, a, b) => {
-                            let predicate = format!("{}: {}", a.to_string(), b.to_string());
+                            let predicate = format!("{a}: {b}");
                             errors
                                 .entry((ty.clone(), predicate.clone()))
                                 .or_default()
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -15,7 +15,6 @@ use crate::mir::interpret::{
 };
 use crate::mir::visit::Visitor;
 use crate::mir::*;
-use crate::ty::RegionUtilitiesExt;
 
 const INDENT: &str = "    ";
 /// Alignment for lining up comments following MIR statements
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -99,8 +99,8 @@ pub use self::predicate::{
     RegionOutlivesPredicate, SubtypePredicate, TraitPredicate, TraitRef, TypeOutlivesPredicate,
 };
 pub use self::region::{
-    EarlyParamRegion, LateParamRegion, LateParamRegionKind, Region, RegionDiagArg, RegionExt,
-    RegionKind, RegionUtilitiesExt, RegionVid,
+    EarlyParamRegion, LateParamRegion, LateParamRegionKind, Region, RegionExt, RegionKind,
+    RegionUtilitiesExt, RegionVid,
 };
 pub use self::sty::{
     AliasTy, AliasTyKind, Article, Binder, BoundConst, BoundRegion, BoundRegionKind, BoundTy,
diff --git a/compiler/rustc_middle/src/ty/opaque_types.rs b/compiler/rustc_middle/src/ty/opaque_types.rs
@@ -5,8 +5,8 @@ use tracing::{debug, instrument, trace};
 
 use crate::error::ConstNotUsedTraitAlias;
 use crate::ty::{
-    self, GenericArg, GenericArgKind, RegionExt, RegionUtilitiesExt, Ty, TyCtxt, TypeFoldable,
-    TypeFolder, TypeSuperFoldable,
+    self, GenericArg, GenericArgKind, RegionExt, Ty, TyCtxt, TypeFoldable, TypeFolder,
+    TypeSuperFoldable,
 };
 
 pub type OpaqueTypeKey<'tcx> = rustc_type_ir::OpaqueTypeKey<TyCtxt<'tcx>>;
@@ -126,17 +126,15 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReverseMapper<'tcx> {
             Some(u) => panic!("region mapped to unexpected kind: {u:?}"),
             None if self.do_not_error => self.tcx.lifetimes.re_static,
             None => {
-                let r = r.to_string();
                 let e = self
                     .tcx
                     .dcx()
                     .struct_span_err(self.span, "non-defining opaque type use in defining scope")
                     .with_span_label(
                         self.span,
                         format!(
-                            "lifetime `{}` is part of concrete type but not used in \
+                            "lifetime `{r}` is part of concrete type but not used in \
                              parameter list of the `impl Trait` type alias",
-                            r
                         ),
                     )
                     .emit();
diff --git a/compiler/rustc_middle/src/ty/region.rs b/compiler/rustc_middle/src/ty/region.rs
@@ -1,42 +1,16 @@
-use std::fmt;
-
-use rustc_errors::{DiagArgValue, IntoDiagArg, MultiSpan};
-use rustc_hir::def::Namespace;
+use rustc_errors::MultiSpan;
 use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, extension};
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Symbol, kw, sym};
 pub use rustc_type_ir::RegionVid;
 use rustc_type_ir::{Region as IrRegion, RegionKind as IrRegionKind};
 use tracing::debug;
 
-use crate::ty::print::{FmtPrinter, Print};
 use crate::ty::{self, BoundVar, TyCtxt, TypeFlags};
 
 pub type Region<'tcx> = IrRegion<TyCtxt<'tcx>>;
 pub type RegionKind<'tcx> = IrRegionKind<TyCtxt<'tcx>>;
 
-#[derive(Copy, Clone)]
-pub struct RegionDisplay<'tcx>(pub Region<'tcx>);
-
-#[derive(Copy, Clone)]
-pub struct RegionDiagArg<'tcx>(pub Region<'tcx>);
-
-impl fmt::Display for RegionDisplay<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        ty::tls::with(|tcx| {
-            let mut p = FmtPrinter::new(tcx, Namespace::TypeNS);
-            tcx.lift(self.0).expect("could not lift region for printing").print(&mut p)?;
-            f.write_str(&p.into_buffer())
-        })
-    }
-}
-
-impl IntoDiagArg for RegionDiagArg<'_> {
-    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
-        DiagArgValue::Str(RegionDisplay(self.0).to_string().into())
-    }
-}
-
 #[extension(pub trait RegionExt<'tcx>)]
 impl<'tcx> Region<'tcx> {
     #[inline]
@@ -118,18 +92,6 @@ impl<'tcx> Region<'tcx> {
 /// Region utilities
 #[extension(pub trait RegionUtilitiesExt<'tcx>)]
 impl<'tcx> Region<'tcx> {
-    fn display(self) -> RegionDisplay<'tcx> {
-        RegionDisplay(self)
-    }
-
-    fn diag_arg(self) -> RegionDiagArg<'tcx> {
-        RegionDiagArg(self)
-    }
-
-    fn to_string(self) -> String {
-        self.display().to_string()
-    }
-
     fn kind(self) -> RegionKind<'tcx> {
         *self.0.0
     }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -2042,7 +2042,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         long_ty_path: &mut Option<PathBuf>,
     ) -> Option<(DiagStyledString, DiagStyledString)> {
         match values {
-            ValuePairs::Regions(exp_found) => self.expected_found_str_region(exp_found),
+            ValuePairs::Regions(exp_found) => self.expected_found_str(exp_found),
             ValuePairs::Terms(exp_found) => self.expected_found_str_term(exp_found, long_ty_path),
             ValuePairs::Aliases(exp_found) => self.expected_found_str(exp_found),
             ValuePairs::ExistentialTraitRef(exp_found) => self.expected_found_str(exp_found),
@@ -2116,21 +2116,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         })
     }
 
-    fn expected_found_str_region(
-        &self,
-        exp_found: ty::error::ExpectedFound<ty::Region<'tcx>>,
-    ) -> Option<(DiagStyledString, DiagStyledString)> {
-        let exp_found = self.resolve_vars_if_possible(exp_found);
-        if exp_found.references_error() {
-            return None;
-        }
-
-        Some((
-            DiagStyledString::highlighted(exp_found.expected.to_string()),
-            DiagStyledString::highlighted(exp_found.found.to_string()),
-        ))
-    }
-
     /// Returns a string of the form "expected `{}`, found `{}`".
     fn expected_found_str<T: fmt::Display + TypeFoldable<TyCtxt<'tcx>>>(
         &self,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -499,7 +499,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     span,
                     impl_item_def_id,
                     trait_item_def_id,
-                    &format!("`{}: {}`", sup.to_string(), sub.to_string()),
+                    &format!("`{sup}: {sub}`"),
                 );
                 // We should only suggest rewriting the `where` clause if the predicate is within that `where` clause
                 if let Some(generics) = self.tcx.hir_get_generics(impl_item_def_id)
@@ -712,7 +712,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 span,
                 impl_item_def_id,
                 trait_item_def_id,
-                &format!("`{bound_kind}: {}`", sub.to_string()),
+                &format!("`{bound_kind}: {sub}`"),
             );
         }
 
@@ -743,7 +743,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 ty::ReEarlyParam(_) | ty::ReLateParam(_) | ty::ReStatic => {
                     msg_span_from_named_region(self.tcx, generic_param_scope, sub, Some(span))
                 }
-                _ => (format!("lifetime `{}`", sub.to_string()), Some(span)),
+                _ => (format!("lifetime `{sub}`"), Some(span)),
             };
             let prefix = format!("{labeled_user_string} must be valid for ");
             label_msg_span(&mut err, &prefix, description, span, "...");
@@ -858,7 +858,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 let suggestion = format!("{} {}", generics.add_where_or_trailing_comma(), pred);
                 suggs.push((generics.tail_span_for_predicate_suggestion(), suggestion))
             } else {
-                let consider = format!("{msg} `{bound_kind}: {}`...", sub.to_string());
+                let consider = format!("{msg} `{bound_kind}: {sub}`...");
                 err.help(consider);
             }
 
@@ -1137,7 +1137,7 @@ pub(super) fn note_and_explain_region<'tcx>(
         ty::ReError(_) => return,
 
         // FIXME(#125431): `ReVar` shouldn't reach here.
-        ty::ReVar(_) => (format!("lifetime `{}`", region.to_string()), alt_span),
+        ty::ReVar(_) => (format!("lifetime `{region}`"), alt_span),
 
         ty::ReBound(..) | ty::ReErased => {
             bug!("unexpected region for note_and_explain_region: {:?}", region);
@@ -1199,7 +1199,7 @@ fn msg_span_from_named_region<'tcx>(
                         Some(tcx.def_span(generic_param_scope)),
                     ),
                     _ => (
-                        format!("the lifetime `{}` as defined here", region.to_string()),
+                        format!("the lifetime `{region}` as defined here"),
                         Some(tcx.def_span(generic_param_scope)),
                     ),
                 }
diff --git a/compiler/rustc_trait_selection/src/errors/note_and_explain.rs b/compiler/rustc_trait_selection/src/errors/note_and_explain.rs
@@ -2,7 +2,7 @@ use rustc_errors::formatting::DiagMessageAddArg;
 use rustc_errors::{Diag, EmissionGuarantee, IntoDiagArg, Subdiagnostic, msg};
 use rustc_hir::def_id::LocalDefId;
 use rustc_middle::bug;
-use rustc_middle::ty::{self, RegionUtilitiesExt, TyCtxt};
+use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::{Span, kw};
 
 use crate::error_reporting::infer::nice_region_error::find_anon_type;
diff --git a/compiler/rustc_type_ir/src/ir_print.rs b/compiler/rustc_type_ir/src/ir_print.rs
@@ -3,8 +3,8 @@ use std::fmt;
 use crate::{
     AliasTerm, AliasTy, Binder, ClosureKind, CoercePredicate, ExistentialProjection,
     ExistentialTraitRef, FnSig, HostEffectPredicate, Interner, NormalizesTo, OutlivesPredicate,
-    PatternKind, Placeholder, ProjectionPredicate, SubtypePredicate, TraitPredicate, TraitRef,
-    UnevaluatedConst,
+    PatternKind, Placeholder, ProjectionPredicate, Region, SubtypePredicate, TraitPredicate,
+    TraitRef, UnevaluatedConst,
 };
 
 pub trait IrPrint<T> {
@@ -54,6 +54,15 @@ define_display_via_print!(
 
 define_debug_via_print!(TraitRef, ExistentialTraitRef, PatternKind);
 
+impl<I: Interner> fmt::Display for Region<I>
+where
+    I: IrPrint<Region<I>>,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <I as IrPrint<Region<I>>>::print(self, fmt)
+    }
+}
+
 impl<I: Interner, T> fmt::Display for OutlivesPredicate<I, T>
 where
     I: IrPrint<OutlivesPredicate<I, T>>,
@@ -99,6 +108,12 @@ mod into_diag_arg_impls {
         }
     }
 
+    impl<I: Interner + IrPrint<Region<I>>> IntoDiagArg for Region<I> {
+        fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+            self.to_string().into_diag_arg(path)
+        }
+    }
+
     impl<I: Interner> IntoDiagArg for UnevaluatedConst<I> {
         fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
             format!("{self:?}").into_diag_arg(path)

Original file line number	Diff line number	Diff line change
`@@ -916,9 +916,7 @@ impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for RemapHiddenTyRegions<'tcx> {`
`916`	`916`	`e`
`917`	`917`	`} else {`
`918`	`918`	`bug!(`
`919`		`- "expected to map region {} to early-bound identity region, but got {}",`
`920`		`- region.to_string(),`
`921`		`- id_region.to_string()`
	`919`	`+ "expected to map region {region} to early-bound identity region, but got {id_region}"`
`922`	`920`	`);`
`923`	`921`	`}`
`924`	`922`	`} else {`