Same for types

compiler-errors · compiler-errors · commit f508b8c8adba · 2025-06-25T16:46:20.000Z
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -2468,7 +2468,7 @@ fn param_env_with_gat_bounds<'tcx>(
         let normalize_impl_ty_args = ty::GenericArgs::identity_for_item(tcx, container_id)
             .extend_to(tcx, impl_ty.def_id, |param, _| match param.kind {
                 GenericParamDefKind::Type { .. } => {
-                    let kind = ty::BoundTyKind::Param(param.def_id, param.name);
+                    let kind = ty::BoundTyKind::Param(param.def_id);
                     let bound_var = ty::BoundVariableKind::Ty(kind);
                     bound_vars.push(bound_var);
                     Ty::new_bound(
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -278,19 +278,13 @@ fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBou
     rbv
 }
 
-fn late_arg_as_bound_arg<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param: &GenericParam<'tcx>,
-) -> ty::BoundVariableKind {
+fn late_arg_as_bound_arg<'tcx>(param: &GenericParam<'tcx>) -> ty::BoundVariableKind {
     let def_id = param.def_id.to_def_id();
-    let name = tcx.item_name(def_id);
     match param.kind {
         GenericParamKind::Lifetime { .. } => {
             ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(def_id))
         }
-        GenericParamKind::Type { .. } => {
-            ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, name))
-        }
+        GenericParamKind::Type { .. } => ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id)),
         GenericParamKind::Const { .. } => ty::BoundVariableKind::Const,
     }
 }
@@ -304,7 +298,7 @@ fn generic_param_def_as_bound_arg(param: &ty::GenericParamDef) -> ty::BoundVaria
             ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(param.def_id))
         }
         ty::GenericParamDefKind::Type { .. } => {
-            ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(param.def_id, param.name))
+            ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(param.def_id))
         }
         ty::GenericParamDefKind::Const { .. } => ty::BoundVariableKind::Const,
     }
@@ -385,7 +379,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
             trait_ref.bound_generic_params.iter().enumerate().map(|(late_bound_idx, param)| {
                 let arg = ResolvedArg::late(initial_bound_vars + late_bound_idx as u32, param);
                 bound_vars.insert(param.def_id, arg);
-                late_arg_as_bound_arg(self.tcx, param)
+                late_arg_as_bound_arg(param)
             });
         binders.extend(binders_iter);
 
@@ -484,7 +478,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                     .map(|(late_bound_idx, param)| {
                         (
                             (param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),
-                            late_arg_as_bound_arg(self.tcx, param),
+                            late_arg_as_bound_arg(param),
                         )
                     })
                     .unzip();
@@ -717,7 +711,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                     .map(|(late_bound_idx, param)| {
                         (
                             (param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),
-                            late_arg_as_bound_arg(self.tcx, param),
+                            late_arg_as_bound_arg(param),
                         )
                     })
                     .unzip();
@@ -747,7 +741,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                         .map(|(late_bound_idx, param)| {
                             (
                                 (param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),
-                                late_arg_as_bound_arg(self.tcx, param),
+                                late_arg_as_bound_arg(param),
                             )
                         })
                         .unzip();
@@ -956,7 +950,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                         .map(|(late_bound_idx, param)| {
                             (
                                 (param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),
-                                late_arg_as_bound_arg(self.tcx, param),
+                                late_arg_as_bound_arg(param),
                             )
                         })
                         .unzip();
@@ -1170,7 +1164,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                 matches!(param.kind, GenericParamKind::Lifetime { .. })
                     && self.tcx.is_late_bound(param.hir_id)
             })
-            .map(|param| late_arg_as_bound_arg(self.tcx, param))
+            .map(|param| late_arg_as_bound_arg(param))
             .collect();
         self.record_late_bound_vars(hir_id, binders);
         let scope = Scope::Binder {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -1048,7 +1048,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 't
             }
             ty::Bound(db, bt) if *db >= self.depth => {
                 self.vars.insert(match bt.kind {
-                    ty::BoundTyKind::Param(def_id, _) => def_id,
+                    ty::BoundTyKind::Param(def_id) => def_id,
                     ty::BoundTyKind::Anon => {
                         let reported = self
                             .cx
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2067,10 +2067,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let tcx = self.tcx();
         match tcx.named_bound_var(hir_id) {
             Some(rbv::ResolvedArg::LateBound(debruijn, index, def_id)) => {
-                let name = tcx.item_name(def_id.to_def_id());
                 let br = ty::BoundTy {
                     var: ty::BoundVar::from_u32(index),
-                    kind: ty::BoundTyKind::Param(def_id.to_def_id(), name),
+                    kind: ty::BoundTyKind::Param(def_id.to_def_id()),
                 };
                 Ty::new_bound(tcx, debruijn, br)
             }
diff --git a/compiler/rustc_lint/src/impl_trait_overcaptures.rs b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
@@ -215,7 +215,7 @@ where
             let arg: ty::BoundVariableKind = arg;
             match arg {
                 ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(def_id))
-                | ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, _)) => {
+                | ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id)) => {
                     added.push(def_id);
                     let unique = self.in_scope_parameters.insert(def_id, ParamKind::Late);
                     assert_eq!(unique, None);
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -795,9 +795,9 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                 ty::BoundTyKind::Anon => {
                     rustc_type_ir::debug_bound_var(self, debruijn, bound_ty.var)?
                 }
-                ty::BoundTyKind::Param(_, s) => match self.should_print_verbose() {
+                ty::BoundTyKind::Param(def_id) => match self.should_print_verbose() {
                     true => p!(write("{:?}", ty.kind())),
-                    false => p!(write("{s}")),
+                    false => p!(write("{}", self.tcx().item_name(def_id))),
                 },
             },
             ty::Adt(def, args) => {
@@ -825,9 +825,9 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             }
             ty::Placeholder(placeholder) => match placeholder.bound.kind {
                 ty::BoundTyKind::Anon => p!(write("{placeholder:?}")),
-                ty::BoundTyKind::Param(_, name) => match self.should_print_verbose() {
+                ty::BoundTyKind::Param(def_id) => match self.should_print_verbose() {
                     true => p!(write("{:?}", ty.kind())),
-                    false => p!(write("{name}")),
+                    false => p!(write("{}", self.tcx().item_name(def_id))),
                 },
             },
             ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => {
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -183,7 +183,7 @@ impl fmt::Debug for ty::BoundTy {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             ty::BoundTyKind::Anon => write!(f, "{:?}", self.var),
-            ty::BoundTyKind::Param(_, sym) => write!(f, "{sym:?}"),
+            ty::BoundTyKind::Param(def_id) => write!(f, "{def_id:?}"),
         }
     }
 }
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -389,7 +389,7 @@ impl<'tcx> rustc_type_ir::inherent::BoundVarLike<TyCtxt<'tcx>> for BoundTy {
 #[derive(HashStable)]
 pub enum BoundTyKind {
     Anon,
-    Param(DefId, Symbol),
+    Param(DefId),
 }
 
 impl From<BoundVar> for BoundTy {
diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/rustc_internal/internal.rs
@@ -6,7 +6,6 @@
 // Prefer importing stable_mir over internal rustc constructs to make this file more readable.
 
 use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy, TyCtxt};
-use rustc_span::Symbol;
 use stable_mir::abi::Layout;
 use stable_mir::mir::alloc::AllocId;
 use stable_mir::mir::mono::{Instance, MonoItem, StaticDef};
@@ -345,10 +344,9 @@ impl RustcInternal for BoundVariableKind {
         match self {
             BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind {
                 BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon,
-                BoundTyKind::Param(def, symbol) => rustc_ty::BoundTyKind::Param(
-                    def.0.internal(tables, tcx),
-                    Symbol::intern(symbol),
-                ),
+                BoundTyKind::Param(def, _symbol) => {
+                    rustc_ty::BoundTyKind::Param(def.0.internal(tables, tcx))
+                }
             }),
             BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind {
                 BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon,
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -230,9 +230,10 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind {
 
         match self {
             ty::BoundTyKind::Anon => BoundTyKind::Anon,
-            ty::BoundTyKind::Param(def_id, symbol) => {
-                BoundTyKind::Param(tables.param_def(*def_id), symbol.to_string())
-            }
+            ty::BoundTyKind::Param(def_id) => BoundTyKind::Param(
+                tables.param_def(*def_id),
+                tables.tcx.item_name(*def_id).to_string(),
+            ),
         }
     }
 }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -2221,7 +2221,7 @@ pub(crate) fn clean_middle_ty<'tcx>(
         }
 
         ty::Bound(_, ref ty) => match ty.kind {
-            ty::BoundTyKind::Param(_, name) => Generic(name),
+            ty::BoundTyKind::Param(def_id) => Generic(cx.tcx.item_name(def_id)),
             ty::BoundTyKind::Anon => panic!("unexpected anonymous bound type variable"),
         },
 
@@ -3188,7 +3188,8 @@ fn clean_bound_vars<'tcx>(
                     None
                 }
             }
-            ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, name)) => {
+            ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id)) => {
+                let name = cx.tcx.item_name(def_id);
                 Some(GenericParamDef {
                     name,
                     def_id,

Original file line number	Diff line number	Diff line change
`@@ -278,19 +278,13 @@ fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBou`
`278`	`278`	`rbv`
`279`	`279`	`}`
`280`	`280`
`281`		`-fn late_arg_as_bound_arg<'tcx>(`
`282`		`- tcx: TyCtxt<'tcx>,`
`283`		`- param: &GenericParam<'tcx>,`
`284`		`-) -> ty::BoundVariableKind {`
	`281`	`+fn late_arg_as_bound_arg<'tcx>(param: &GenericParam<'tcx>) -> ty::BoundVariableKind {`
`285`	`282`	`let def_id = param.def_id.to_def_id();`
`286`		`- let name = tcx.item_name(def_id);`
`287`	`283`	`match param.kind {`
`288`	`284`	`GenericParamKind::Lifetime { .. } => {`
`289`	`285`	`ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(def_id))`
`290`	`286`	`}`
`291`		`- GenericParamKind::Type { .. } => {`
`292`		`- ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, name))`
`293`		`- }`
	`287`	`+ GenericParamKind::Type { .. } => ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id)),`
`294`	`288`	`GenericParamKind::Const { .. } => ty::BoundVariableKind::Const,`
`295`	`289`	`}`
`296`	`290`	`}`
`@@ -304,7 +298,7 @@ fn generic_param_def_as_bound_arg(param: &ty::GenericParamDef) -> ty::BoundVaria`
`304`	`298`	`ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(param.def_id))`
`305`	`299`	`}`
`306`	`300`	`ty::GenericParamDefKind::Type { .. } => {`
`307`		`- ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(param.def_id, param.name))`
	`301`	`+ ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(param.def_id))`
`308`	`302`	`}`
`309`	`303`	`ty::GenericParamDefKind::Const { .. } => ty::BoundVariableKind::Const,`
`310`	`304`	`}`
`@@ -385,7 +379,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {`
`385`	`379`	`trait_ref.bound_generic_params.iter().enumerate().map(\|(late_bound_idx, param)\| {`
`386`	`380`	`let arg = ResolvedArg::late(initial_bound_vars + late_bound_idx as u32, param);`
`387`	`381`	`bound_vars.insert(param.def_id, arg);`
`388`		`- late_arg_as_bound_arg(self.tcx, param)`
	`382`	`+ late_arg_as_bound_arg(param)`
`389`	`383`	`});`
`390`	`384`	`binders.extend(binders_iter);`
`391`	`385`
`@@ -484,7 +478,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`484`	`478`	`.map(\|(late_bound_idx, param)\| {`
`485`	`479`	`(`
`486`	`480`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`487`		`- late_arg_as_bound_arg(self.tcx, param),`
	`481`	`+ late_arg_as_bound_arg(param),`
`488`	`482`	`)`
`489`	`483`	`})`
`490`	`484`	`.unzip();`
`@@ -717,7 +711,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`717`	`711`	`.map(\|(late_bound_idx, param)\| {`
`718`	`712`	`(`
`719`	`713`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`720`		`- late_arg_as_bound_arg(self.tcx, param),`
	`714`	`+ late_arg_as_bound_arg(param),`
`721`	`715`	`)`
`722`	`716`	`})`
`723`	`717`	`.unzip();`
`@@ -747,7 +741,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`747`	`741`	`.map(\|(late_bound_idx, param)\| {`
`748`	`742`	`(`
`749`	`743`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`750`		`- late_arg_as_bound_arg(self.tcx, param),`
	`744`	`+ late_arg_as_bound_arg(param),`
`751`	`745`	`)`
`752`	`746`	`})`
`753`	`747`	`.unzip();`
`@@ -956,7 +950,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`956`	`950`	`.map(\|(late_bound_idx, param)\| {`
`957`	`951`	`(`
`958`	`952`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`959`		`- late_arg_as_bound_arg(self.tcx, param),`
	`953`	`+ late_arg_as_bound_arg(param),`
`960`	`954`	`)`
`961`	`955`	`})`
`962`	`956`	`.unzip();`
`@@ -1170,7 +1164,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {`
`1170`	`1164`	`matches!(param.kind, GenericParamKind::Lifetime { .. })`
`1171`	`1165`	`&& self.tcx.is_late_bound(param.hir_id)`
`1172`	`1166`	`})`
`1173`		`- .map(\|param\| late_arg_as_bound_arg(self.tcx, param))`
	`1167`	`+ .map(\|param\| late_arg_as_bound_arg(param))`
`1174`	`1168`	`.collect();`
`1175`	`1169`	`self.record_late_bound_vars(hir_id, binders);`
`1176`	`1170`	`let scope = Scope::Binder {`
Original file line number	Diff line number	Diff line change
`@@ -1048,7 +1048,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 't`
`1048`	`1048`	`}`
`1049`	`1049`	`ty::Bound(db, bt) if *db >= self.depth => {`
`1050`	`1050`	`self.vars.insert(match bt.kind {`
`1051`		`- ty::BoundTyKind::Param(def_id, _) => def_id,`
	`1051`	`+ ty::BoundTyKind::Param(def_id) => def_id,`
`1052`	`1052`	`ty::BoundTyKind::Anon => {`
`1053`	`1053`	`let reported = self`
`1054`	`1054`	`.cx`
Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ impl fmt::Debug for ty::BoundTy {`
`183`	`183`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`184`	`184`	`match self.kind {`
`185`	`185`	`ty::BoundTyKind::Anon => write!(f, "{:?}", self.var),`
`186`		`- ty::BoundTyKind::Param(_, sym) => write!(f, "{sym:?}"),`
	`186`	`+ ty::BoundTyKind::Param(def_id) => write!(f, "{def_id:?}"),`
`187`	`187`	`}`
`188`	`188`	`}`
`189`	`189`	`}`
Original file line number	Diff line number	Diff line change
`@@ -389,7 +389,7 @@ impl<'tcx> rustc_type_ir::inherent::BoundVarLike<TyCtxt<'tcx>> for BoundTy {`
`389`	`389`	`#[derive(HashStable)]`
`390`	`390`	`pub enum BoundTyKind {`
`391`	`391`	`Anon,`
`392`		`- Param(DefId, Symbol),`
	`392`	`+ Param(DefId),`
`393`	`393`	`}`
`394`	`394`
`395`	`395`	`impl From<BoundVar> for BoundTy {`
Original file line number	Diff line number	Diff line change
`@@ -230,9 +230,10 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind {`
`230`	`230`
`231`	`231`	`match self {`
`232`	`232`	`ty::BoundTyKind::Anon => BoundTyKind::Anon,`
`233`		`- ty::BoundTyKind::Param(def_id, symbol) => {`
`234`		`- BoundTyKind::Param(tables.param_def(*def_id), symbol.to_string())`
`235`		`- }`
	`233`	`+ ty::BoundTyKind::Param(def_id) => BoundTyKind::Param(`
	`234`	`+ tables.param_def(*def_id),`
	`235`	`+ tables.tcx.item_name(*def_id).to_string(),`
	`236`	`+ ),`
`236`	`237`	`}`
`237`	`238`	`}`
`238`	`239`	`}`