Revert "Rollup merge of rust-lang#99342 - TaKO8Ki:avoid-symbol-to-string-conversions, r=compiler-errors"

matthiaskrgr · matthiaskrgr · commit 6537d3966d04 · 2022-07-17T11:40:49.000+02:00
This reverts commit 6277ac2, reversing changes made to 0c6e01b.
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -23,7 +23,7 @@ use rustc_middle::ty::{
 use rustc_mir_dataflow::move_paths::{InitKind, MoveOutIndex, MovePathIndex};
 use rustc_span::hygiene::DesugaringKind;
 use rustc_span::symbol::sym;
-use rustc_span::{BytePos, Span, Symbol};
+use rustc_span::{BytePos, Span};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::TraitEngineExt as _;
 
@@ -1227,7 +1227,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                     from_closure: false,
                     region_name:
                         RegionName {
-                            source: RegionNameSource::AnonRegionFromUpvar(upvar_span, upvar_name),
+                            source:
+                                RegionNameSource::AnonRegionFromUpvar(upvar_span, ref upvar_name),
                             ..
                         },
                     span,
@@ -1761,7 +1762,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         borrow_span: Span,
         name: &Option<String>,
         upvar_span: Span,
-        upvar_name: Symbol,
+        upvar_name: &str,
         escape_span: Span,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
         let tcx = self.infcx.tcx;
diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -12,7 +12,7 @@ use rustc_middle::mir::{
 };
 use rustc_middle::ty::adjustment::PointerCast;
 use rustc_middle::ty::{self, RegionVid, TyCtxt};
-use rustc_span::symbol::{kw, Symbol};
+use rustc_span::symbol::Symbol;
 use rustc_span::{sym, DesugaringKind, Span};
 
 use crate::region_infer::BlameConstraint;
@@ -282,7 +282,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
     ) {
         if let ConstraintCategory::OpaqueType = category {
             let suggestable_name =
-                if region_name.was_named() { region_name.name } else { kw::UnderscoreLifetime };
+                if region_name.was_named() { region_name.to_string() } else { "'_".to_string() };
 
             let msg = format!(
                 "you can add a bound to the {}to make it last less than `'static` and match `{}`",
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
@@ -19,7 +19,8 @@ use rustc_middle::ty::subst::InternalSubsts;
 use rustc_middle::ty::Region;
 use rustc_middle::ty::TypeVisitor;
 use rustc_middle::ty::{self, RegionVid, Ty};
-use rustc_span::symbol::{kw, sym, Ident};
+use rustc_span::symbol::sym;
+use rustc_span::symbol::Ident;
 use rustc_span::Span;
 
 use crate::borrowck_errors;
@@ -757,7 +758,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                 return;
             };
 
-            let lifetime = if f.has_name() { fr_name.name } else { kw::UnderscoreLifetime };
+            let lifetime = if f.has_name() { fr_name.to_string() } else { "'_".to_string() };
 
             let arg = match param.param.pat.simple_ident() {
                 Some(simple_ident) => format!("argument `{}`", simple_ident),
@@ -769,7 +770,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                 self.infcx.tcx,
                 diag,
                 fn_returns,
-                lifetime.to_string(),
+                lifetime,
                 Some(arg),
                 captures,
                 Some((param.param_ty_span, param.param_ty.to_string())),
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -34,13 +34,13 @@ pub(crate) enum RegionNameSource {
     /// The `'static` region.
     Static,
     /// The free region corresponding to the environment of a closure.
-    SynthesizedFreeEnvRegion(Span, &'static str),
+    SynthesizedFreeEnvRegion(Span, String),
     /// The region corresponding to an argument.
     AnonRegionFromArgument(RegionNameHighlight),
     /// The region corresponding to a closure upvar.
-    AnonRegionFromUpvar(Span, Symbol),
+    AnonRegionFromUpvar(Span, String),
     /// The region corresponding to the return type of a closure.
-    AnonRegionFromOutput(RegionNameHighlight, &'static str),
+    AnonRegionFromOutput(RegionNameHighlight, String),
     /// The region from a type yielded by a generator.
     AnonRegionFromYieldTy(Span, String),
     /// An anonymous region from an async fn.
@@ -110,7 +110,7 @@ impl RegionName {
             }
             RegionNameSource::SynthesizedFreeEnvRegion(span, note) => {
                 diag.span_label(*span, format!("lifetime `{self}` represents this closure's body"));
-                diag.note(*note);
+                diag.note(note);
             }
             RegionNameSource::AnonRegionFromArgument(RegionNameHighlight::CannotMatchHirTy(
                 span,
@@ -350,7 +350,10 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
 
                     Some(RegionName {
                         name: region_name,
-                        source: RegionNameSource::SynthesizedFreeEnvRegion(fn_decl_span, note),
+                        source: RegionNameSource::SynthesizedFreeEnvRegion(
+                            fn_decl_span,
+                            note.to_string(),
+                        ),
                     })
                 }
 
@@ -675,7 +678,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
 
         Some(RegionName {
             name: region_name,
-            source: RegionNameSource::AnonRegionFromUpvar(upvar_span, upvar_name),
+            source: RegionNameSource::AnonRegionFromUpvar(upvar_span, upvar_name.to_string()),
         })
     }
 
@@ -753,7 +756,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
 
         Some(RegionName {
             name: self.synthesize_region_name(),
-            source: RegionNameSource::AnonRegionFromOutput(highlight, mir_description),
+            source: RegionNameSource::AnonRegionFromOutput(highlight, mir_description.to_string()),
         })
     }
 
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
@@ -453,7 +453,7 @@ impl Diagnostic {
         self
     }
 
-    pub fn note_trait_signature(&mut self, name: Symbol, signature: String) -> &mut Self {
+    pub fn note_trait_signature(&mut self, name: String, signature: String) -> &mut Self {
         self.highlighted_note(vec![
             (format!("`{}` from trait: `", name), Style::NoStyle),
             (signature, Style::Highlight),
diff --git a/compiler/rustc_expand/src/module.rs b/compiler/rustc_expand/src/module.rs
@@ -218,9 +218,10 @@ pub fn default_submod_path<'a>(
         ""
     };
 
-    let default_path_str = format!("{}{}.rs", relative_prefix, ident.name);
+    let mod_name = ident.name.to_string();
+    let default_path_str = format!("{}{}.rs", relative_prefix, mod_name);
     let secondary_path_str =
-        format!("{}{}{}mod.rs", relative_prefix, ident.name, path::MAIN_SEPARATOR);
+        format!("{}{}{}mod.rs", relative_prefix, mod_name, path::MAIN_SEPARATOR);
     let default_path = dir_path.join(&default_path_str);
     let secondary_path = dir_path.join(&secondary_path_str);
     let default_exists = sess.source_map().file_exists(&default_path);
diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
@@ -138,7 +138,7 @@ fn fmt_printer<'a, 'tcx>(infcx: &'a InferCtxt<'_, 'tcx>, ns: Namespace) -> FmtPr
         if let TypeVariableOriginKind::TypeParameterDefinition(name, _) =
             infcx.inner.borrow_mut().type_variables().var_origin(ty_vid).kind
         {
-            Some(name)
+            Some(name.to_string())
         } else {
             None
         }
@@ -151,7 +151,7 @@ fn fmt_printer<'a, 'tcx>(infcx: &'a InferCtxt<'_, 'tcx>, ns: Namespace) -> FmtPr
         if let ConstVariableOriginKind::ConstParameterDefinition(name, _) =
             infcx.inner.borrow_mut().const_unification_table().probe_value(ct_vid).origin.kind
         {
-            return Some(name);
+            return Some(name.to_string());
         } else {
             None
         }
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
@@ -1975,7 +1975,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                         min_size = field_end;
                     }
                     FieldInfo {
-                        name,
+                        name: name.to_string(),
                         offset: offset.bytes(),
                         size: field_layout.size.bytes(),
                         align: field_layout.align.abi.bytes(),
@@ -1984,7 +1984,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                 .collect();
 
             VariantInfo {
-                name: n,
+                name: n.map(|n| n.to_string()),
                 kind: if layout.is_unsized() { SizeKind::Min } else { SizeKind::Exact },
                 align: layout.align.abi.bytes(),
                 size: if min_size.bytes() == 0 { layout.size.bytes() } else { min_size.bytes() },
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1030,11 +1030,11 @@ pub trait PrettyPrinter<'tcx>:
         }
     }
 
-    fn ty_infer_name(&self, _: ty::TyVid) -> Option<Symbol> {
+    fn ty_infer_name(&self, _: ty::TyVid) -> Option<String> {
         None
     }
 
-    fn const_infer_name(&self, _: ty::ConstVid<'tcx>) -> Option<Symbol> {
+    fn const_infer_name(&self, _: ty::ConstVid<'tcx>) -> Option<String> {
         None
     }
 
@@ -1550,8 +1550,8 @@ pub struct FmtPrinterData<'a, 'tcx> {
 
     pub region_highlight_mode: RegionHighlightMode<'tcx>,
 
-    pub ty_infer_name_resolver: Option<Box<dyn Fn(ty::TyVid) -> Option<Symbol> + 'a>>,
-    pub const_infer_name_resolver: Option<Box<dyn Fn(ty::ConstVid<'tcx>) -> Option<Symbol> + 'a>>,
+    pub ty_infer_name_resolver: Option<Box<dyn Fn(ty::TyVid) -> Option<String> + 'a>>,
+    pub const_infer_name_resolver: Option<Box<dyn Fn(ty::ConstVid<'tcx>) -> Option<String> + 'a>>,
 }
 
 impl<'a, 'tcx> Deref for FmtPrinter<'a, 'tcx> {
@@ -1841,11 +1841,11 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {
 }
 
 impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {
-    fn ty_infer_name(&self, id: ty::TyVid) -> Option<Symbol> {
+    fn ty_infer_name(&self, id: ty::TyVid) -> Option<String> {
         self.0.ty_infer_name_resolver.as_ref().and_then(|func| func(id))
     }
 
-    fn const_infer_name(&self, id: ty::ConstVid<'tcx>) -> Option<Symbol> {
+    fn const_infer_name(&self, id: ty::ConstVid<'tcx>) -> Option<String> {
         self.0.const_infer_name_resolver.as_ref().and_then(|func| func(id))
     }
 
diff --git a/compiler/rustc_session/src/code_stats.rs b/compiler/rustc_session/src/code_stats.rs
@@ -1,12 +1,11 @@
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::Lock;
-use rustc_span::Symbol;
 use rustc_target::abi::{Align, Size};
 use std::cmp::{self, Ordering};
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct VariantInfo {
-    pub name: Option<Symbol>,
+    pub name: Option<String>,
     pub kind: SizeKind,
     pub size: u64,
     pub align: u64,
@@ -21,7 +20,7 @@ pub enum SizeKind {
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct FieldInfo {
-    pub name: Symbol,
+    pub name: String,
     pub offset: u64,
     pub size: u64,
     pub align: u64,
@@ -120,7 +119,7 @@ impl CodeStats {
                 let VariantInfo { ref name, kind: _, align: _, size, ref fields } = *variant_info;
                 let indent = if !struct_like {
                     let name = match name.as_ref() {
-                        Some(name) => name.to_string(),
+                        Some(name) => name.to_owned(),
                         None => i.to_string(),
                     };
                     println!(
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -2486,7 +2486,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                                         concrete type's name `{type_name}` instead if you want to \
                                         specify its type parameters"
                                     ),
-                                    type_name,
+                                    type_name.to_string(),
                                     Applicability::MaybeIncorrect,
                                 );
                             }
diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs
@@ -544,7 +544,7 @@ fn compare_self_type<'tcx>(
             if let Some(span) = tcx.hir().span_if_local(trait_m.def_id) {
                 err.span_label(span, format!("trait method declared without `{self_descr}`"));
             } else {
-                err.note_trait_signature(trait_m.name, trait_m.signature(tcx));
+                err.note_trait_signature(trait_m.name.to_string(), trait_m.signature(tcx));
             }
             let reported = err.emit();
             return Err(reported);
@@ -564,7 +564,7 @@ fn compare_self_type<'tcx>(
             if let Some(span) = tcx.hir().span_if_local(trait_m.def_id) {
                 err.span_label(span, format!("`{self_descr}` used in trait"));
             } else {
-                err.note_trait_signature(trait_m.name, trait_m.signature(tcx));
+                err.note_trait_signature(trait_m.name.to_string(), trait_m.signature(tcx));
             }
             let reported = err.emit();
             return Err(reported);
@@ -803,7 +803,7 @@ fn compare_number_of_method_arguments<'tcx>(
                 ),
             );
         } else {
-            err.note_trait_signature(trait_m.name, trait_m.signature(tcx));
+            err.note_trait_signature(trait_m.name.to_string(), trait_m.signature(tcx));
         }
         err.span_label(
             impl_span,
diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs
@@ -1856,7 +1856,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let remaining_private_fields_len = remaining_private_fields.len();
             let names = match &remaining_private_fields
                 .iter()
-                .map(|(name, _, _)| name)
+                .map(|(name, _, _)| name.to_string())
                 .collect::<Vec<_>>()[..]
             {
                 _ if remaining_private_fields_len > 6 => String::new(),
diff --git a/compiler/rustc_typeck/src/check/method/suggest.rs b/compiler/rustc_typeck/src/check/method/suggest.rs
@@ -19,7 +19,6 @@ use rustc_middle::ty::print::with_crate_prefix;
 use rustc_middle::ty::ToPolyTraitRef;
 use rustc_middle::ty::{self, DefIdTree, ToPredicate, Ty, TyCtxt, TypeVisitable};
 use rustc_span::symbol::{kw, sym, Ident};
-use rustc_span::Symbol;
 use rustc_span::{lev_distance, source_map, ExpnKind, FileName, MacroKind, Span};
 use rustc_trait_selection::traits::error_reporting::on_unimplemented::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
@@ -1549,7 +1548,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             Option<ObligationCause<'tcx>>,
         )],
     ) {
-        let mut derives = Vec::<(String, Span, Symbol)>::new();
+        let mut derives = Vec::<(String, Span, String)>::new();
         let mut traits = Vec::<Span>::new();
         for (pred, _, _) in unsatisfied_predicates {
             let ty::PredicateKind::Trait(trait_pred) = pred.kind().skip_binder() else { continue };
@@ -1582,12 +1581,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 derives.push((
                                     self_name.clone(),
                                     self_span,
-                                    parent_diagnostic_name,
+                                    parent_diagnostic_name.to_string(),
                                 ));
                             }
                         }
                     }
-                    derives.push((self_name, self_span, diagnostic_name));
+                    derives.push((self_name, self_span, diagnostic_name.to_string()));
                 } else {
                     traits.push(self.tcx.def_span(trait_pred.def_id()));
                 }
@@ -1610,7 +1609,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     continue;
                 }
             }
-            derives_grouped.push((self_name, self_span, trait_name.to_string()));
+            derives_grouped.push((self_name, self_span, trait_name));
         }
 
         let len = traits.len();
diff --git a/compiler/rustc_typeck/src/impl_wf_check.rs b/compiler/rustc_typeck/src/impl_wf_check.rs
@@ -17,7 +17,7 @@ use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::{self, TyCtxt, TypeVisitable};
-use rustc_span::{Span, Symbol};
+use rustc_span::Span;
 
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 
@@ -123,7 +123,12 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
             ty::GenericParamDefKind::Type { .. } => {
                 let param_ty = ty::ParamTy::for_def(param);
                 if !input_parameters.contains(&cgp::Parameter::from(param_ty)) {
-                    report_unused_parameter(tcx, tcx.def_span(param.def_id), "type", param_ty.name);
+                    report_unused_parameter(
+                        tcx,
+                        tcx.def_span(param.def_id),
+                        "type",
+                        &param_ty.to_string(),
+                    );
                 }
             }
             ty::GenericParamDefKind::Lifetime => {
@@ -135,7 +140,7 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
                         tcx,
                         tcx.def_span(param.def_id),
                         "lifetime",
-                        param.name,
+                        &param.name.to_string(),
                     );
                 }
             }
@@ -146,7 +151,7 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
                         tcx,
                         tcx.def_span(param.def_id),
                         "const",
-                        param_ct.name,
+                        &param_ct.to_string(),
                     );
                 }
             }
@@ -173,7 +178,7 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
     // used elsewhere are not projected back out.
 }
 
-fn report_unused_parameter(tcx: TyCtxt<'_>, span: Span, kind: &str, name: Symbol) {
+fn report_unused_parameter(tcx: TyCtxt<'_>, span: Span, kind: &str, name: &str) {
     let mut err = struct_span_err!(
         tcx.sess,
         span,
diff --git a/src/tools/clippy/clippy_lints/src/format.rs b/src/tools/clippy/clippy_lints/src/format.rs
diff --git a/src/tools/clippy/clippy_lints/src/inherent_to_string.rs b/src/tools/clippy/clippy_lints/src/inherent_to_string.rs
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs

Original file line number	Diff line number	Diff line change
`@@ -453,7 +453,7 @@ impl Diagnostic {`
`453`	`453`	`self`
`454`	`454`	`}`
`455`	`455`
`456`		`- pub fn note_trait_signature(&mut self, name: Symbol, signature: String) -> &mut Self {`
	`456`	`+ pub fn note_trait_signature(&mut self, name: String, signature: String) -> &mut Self {`
`457`	`457`	`self.highlighted_note(vec![`
`458`	`458`	(format!("`{}` from trait: `", name), Style::NoStyle),
`459`	`459`	`(signature, Style::Highlight),`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ fn fmt_printer<'a, 'tcx>(infcx: &'a InferCtxt<'_, 'tcx>, ns: Namespace) -> FmtPr`
`138`	`138`	`if let TypeVariableOriginKind::TypeParameterDefinition(name, _) =`
`139`	`139`	`infcx.inner.borrow_mut().type_variables().var_origin(ty_vid).kind`
`140`	`140`	`{`
`141`		`- Some(name)`
	`141`	`+ Some(name.to_string())`
`142`	`142`	`} else {`
`143`	`143`	`None`
`144`	`144`	`}`
`@@ -151,7 +151,7 @@ fn fmt_printer<'a, 'tcx>(infcx: &'a InferCtxt<'_, 'tcx>, ns: Namespace) -> FmtPr`
`151`	`151`	`if let ConstVariableOriginKind::ConstParameterDefinition(name, _) =`
`152`	`152`	`infcx.inner.borrow_mut().const_unification_table().probe_value(ct_vid).origin.kind`
`153`	`153`	`{`
`154`		`- return Some(name);`
	`154`	`+ return Some(name.to_string());`
`155`	`155`	`} else {`
`156`	`156`	`None`
`157`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1030,11 +1030,11 @@ pub trait PrettyPrinter<'tcx>:`
`1030`	`1030`	`}`
`1031`	`1031`	`}`
`1032`	`1032`
`1033`		`- fn ty_infer_name(&self, _: ty::TyVid) -> Option<Symbol> {`
	`1033`	`+ fn ty_infer_name(&self, _: ty::TyVid) -> Option<String> {`
`1034`	`1034`	`None`
`1035`	`1035`	`}`
`1036`	`1036`
`1037`		`- fn const_infer_name(&self, _: ty::ConstVid<'tcx>) -> Option<Symbol> {`
	`1037`	`+ fn const_infer_name(&self, _: ty::ConstVid<'tcx>) -> Option<String> {`
`1038`	`1038`	`None`
`1039`	`1039`	`}`
`1040`	`1040`
`@@ -1550,8 +1550,8 @@ pub struct FmtPrinterData<'a, 'tcx> {`
`1550`	`1550`
`1551`	`1551`	`pub region_highlight_mode: RegionHighlightMode<'tcx>,`
`1552`	`1552`
`1553`		`- pub ty_infer_name_resolver: Option<Box<dyn Fn(ty::TyVid) -> Option<Symbol> + 'a>>,`
`1554`		`- pub const_infer_name_resolver: Option<Box<dyn Fn(ty::ConstVid<'tcx>) -> Option<Symbol> + 'a>>,`
	`1553`	`+ pub ty_infer_name_resolver: Option<Box<dyn Fn(ty::TyVid) -> Option<String> + 'a>>,`
	`1554`	`+ pub const_infer_name_resolver: Option<Box<dyn Fn(ty::ConstVid<'tcx>) -> Option<String> + 'a>>,`
`1555`	`1555`	`}`
`1556`	`1556`
`1557`	`1557`	`impl<'a, 'tcx> Deref for FmtPrinter<'a, 'tcx> {`
`@@ -1841,11 +1841,11 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {`
`1841`	`1841`	`}`
`1842`	`1842`
`1843`	`1843`	`impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {`
`1844`		`- fn ty_infer_name(&self, id: ty::TyVid) -> Option<Symbol> {`
	`1844`	`+ fn ty_infer_name(&self, id: ty::TyVid) -> Option<String> {`
`1845`	`1845`	`self.0.ty_infer_name_resolver.as_ref().and_then(\|func\| func(id))`
`1846`	`1846`	`}`
`1847`	`1847`
`1848`		`- fn const_infer_name(&self, id: ty::ConstVid<'tcx>) -> Option<Symbol> {`
	`1848`	`+ fn const_infer_name(&self, id: ty::ConstVid<'tcx>) -> Option<String> {`
`1849`	`1849`	`self.0.const_infer_name_resolver.as_ref().and_then(\|func\| func(id))`
`1850`	`1850`	`}`
`1851`	`1851`
Original file line number	Diff line number	Diff line change
`@@ -2486,7 +2486,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`2486`	`2486`	concrete type's name `{type_name}` instead if you want to \
`2487`	`2487`	`specify its type parameters"`
`2488`	`2488`	`),`
`2489`		`- type_name,`
	`2489`	`+ type_name.to_string(),`
`2490`	`2490`	`Applicability::MaybeIncorrect,`
`2491`	`2491`	`);`
`2492`	`2492`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1856,7 +1856,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1856`	`1856`	`let remaining_private_fields_len = remaining_private_fields.len();`
`1857`	`1857`	`let names = match &remaining_private_fields`
`1858`	`1858`	`.iter()`
`1859`		`- .map(\|(name, _, _)\| name)`
	`1859`	`+ .map(\|(name, _, _)\| name.to_string())`
`1860`	`1860`	`.collect::<Vec<_>>()[..]`
`1861`	`1861`	`{`
`1862`	`1862`	`_ if remaining_private_fields_len > 6 => String::new(),`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,6 @@ use rustc_middle::ty::print::with_crate_prefix;`
`19`	`19`	`use rustc_middle::ty::ToPolyTraitRef;`
`20`	`20`	`use rustc_middle::ty::{self, DefIdTree, ToPredicate, Ty, TyCtxt, TypeVisitable};`
`21`	`21`	`use rustc_span::symbol::{kw, sym, Ident};`
`22`		`-use rustc_span::Symbol;`
`23`	`22`	`use rustc_span::{lev_distance, source_map, ExpnKind, FileName, MacroKind, Span};`
`24`	`23`	`use rustc_trait_selection::traits::error_reporting::on_unimplemented::InferCtxtExt as _;`
`25`	`24`	`use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;`
`@@ -1549,7 +1548,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1549`	`1548`	`Option<ObligationCause<'tcx>>,`
`1550`	`1549`	`)],`
`1551`	`1550`	`) {`
`1552`		`- let mut derives = Vec::<(String, Span, Symbol)>::new();`
	`1551`	`+ let mut derives = Vec::<(String, Span, String)>::new();`
`1553`	`1552`	`let mut traits = Vec::<Span>::new();`
`1554`	`1553`	`for (pred, _, _) in unsatisfied_predicates {`
`1555`	`1554`	`let ty::PredicateKind::Trait(trait_pred) = pred.kind().skip_binder() else { continue };`
`@@ -1582,12 +1581,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1582`	`1581`	`derives.push((`
`1583`	`1582`	`self_name.clone(),`
`1584`	`1583`	`self_span,`
`1585`		`- parent_diagnostic_name,`
	`1584`	`+ parent_diagnostic_name.to_string(),`
`1586`	`1585`	`));`
`1587`	`1586`	`}`
`1588`	`1587`	`}`
`1589`	`1588`	`}`
`1590`		`- derives.push((self_name, self_span, diagnostic_name));`
	`1589`	`+ derives.push((self_name, self_span, diagnostic_name.to_string()));`
`1591`	`1590`	`} else {`
`1592`	`1591`	`traits.push(self.tcx.def_span(trait_pred.def_id()));`
`1593`	`1592`	`}`
`@@ -1610,7 +1609,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1610`	`1609`	`continue;`
`1611`	`1610`	`}`
`1612`	`1611`	`}`
`1613`		`- derives_grouped.push((self_name, self_span, trait_name.to_string()));`
	`1612`	`+ derives_grouped.push((self_name, self_span, trait_name));`
`1614`	`1613`	`}`
`1615`	`1614`
`1616`	`1615`	`let len = traits.len();`