Same for types

compiler-errors · compiler-errors · commit 74570e526e68 · 2025-07-04T18:26:09.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
@@ -279,19 +279,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,
     }
 }
@@ -305,7 +299,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,
     }
@@ -386,7 +380,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);
 
@@ -485,7 +479,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();
@@ -718,7 +712,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();
@@ -748,7 +742,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();
@@ -957,7 +951,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();
@@ -1171,7 +1165,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
@@ -1050,7 +1050,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) => {
@@ -824,9 +824,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
@@ -400,7 +400,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/stable_mir/unstable/convert/internal.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs
@@ -7,7 +7,6 @@
 
 use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy};
 use rustc_smir::Tables;
-use rustc_span::Symbol;
 use stable_mir::abi::Layout;
 use stable_mir::compiler_interface::BridgeTys;
 use stable_mir::mir::alloc::AllocId;
@@ -446,10 +445,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/stable_mir/unstable/convert/stable/ty.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs
@@ -291,14 +291,14 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        _: &SmirCtxt<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use stable_mir::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), cx.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"),
         },
 
@@ -3192,7 +3192,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
`@@ -279,19 +279,13 @@ fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBou`
`279`	`279`	`rbv`
`280`	`280`	`}`
`281`	`281`
`282`		`-fn late_arg_as_bound_arg<'tcx>(`
`283`		`- tcx: TyCtxt<'tcx>,`
`284`		`- param: &GenericParam<'tcx>,`
`285`		`-) -> ty::BoundVariableKind {`
	`282`	`+fn late_arg_as_bound_arg<'tcx>(param: &GenericParam<'tcx>) -> ty::BoundVariableKind {`
`286`	`283`	`let def_id = param.def_id.to_def_id();`
`287`		`- let name = tcx.item_name(def_id);`
`288`	`284`	`match param.kind {`
`289`	`285`	`GenericParamKind::Lifetime { .. } => {`
`290`	`286`	`ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(def_id))`
`291`	`287`	`}`
`292`		`- GenericParamKind::Type { .. } => {`
`293`		`- ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, name))`
`294`		`- }`
	`288`	`+ GenericParamKind::Type { .. } => ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id)),`
`295`	`289`	`GenericParamKind::Const { .. } => ty::BoundVariableKind::Const,`
`296`	`290`	`}`
`297`	`291`	`}`
`@@ -305,7 +299,7 @@ fn generic_param_def_as_bound_arg(param: &ty::GenericParamDef) -> ty::BoundVaria`
`305`	`299`	`ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(param.def_id))`
`306`	`300`	`}`
`307`	`301`	`ty::GenericParamDefKind::Type { .. } => {`
`308`		`- ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(param.def_id, param.name))`
	`302`	`+ ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(param.def_id))`
`309`	`303`	`}`
`310`	`304`	`ty::GenericParamDefKind::Const { .. } => ty::BoundVariableKind::Const,`
`311`	`305`	`}`
`@@ -386,7 +380,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {`
`386`	`380`	`trait_ref.bound_generic_params.iter().enumerate().map(\|(late_bound_idx, param)\| {`
`387`	`381`	`let arg = ResolvedArg::late(initial_bound_vars + late_bound_idx as u32, param);`
`388`	`382`	`bound_vars.insert(param.def_id, arg);`
`389`		`- late_arg_as_bound_arg(self.tcx, param)`
	`383`	`+ late_arg_as_bound_arg(param)`
`390`	`384`	`});`
`391`	`385`	`binders.extend(binders_iter);`
`392`	`386`
`@@ -485,7 +479,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`485`	`479`	`.map(\|(late_bound_idx, param)\| {`
`486`	`480`	`(`
`487`	`481`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`488`		`- late_arg_as_bound_arg(self.tcx, param),`
	`482`	`+ late_arg_as_bound_arg(param),`
`489`	`483`	`)`
`490`	`484`	`})`
`491`	`485`	`.unzip();`
`@@ -718,7 +712,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`718`	`712`	`.map(\|(late_bound_idx, param)\| {`
`719`	`713`	`(`
`720`	`714`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`721`		`- late_arg_as_bound_arg(self.tcx, param),`
	`715`	`+ late_arg_as_bound_arg(param),`
`722`	`716`	`)`
`723`	`717`	`})`
`724`	`718`	`.unzip();`
`@@ -748,7 +742,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`748`	`742`	`.map(\|(late_bound_idx, param)\| {`
`749`	`743`	`(`
`750`	`744`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`751`		`- late_arg_as_bound_arg(self.tcx, param),`
	`745`	`+ late_arg_as_bound_arg(param),`
`752`	`746`	`)`
`753`	`747`	`})`
`754`	`748`	`.unzip();`
`@@ -957,7 +951,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`957`	`951`	`.map(\|(late_bound_idx, param)\| {`
`958`	`952`	`(`
`959`	`953`	`(param.def_id, ResolvedArg::late(late_bound_idx as u32, param)),`
`960`		`- late_arg_as_bound_arg(self.tcx, param),`
	`954`	`+ late_arg_as_bound_arg(param),`
`961`	`955`	`)`
`962`	`956`	`})`
`963`	`957`	`.unzip();`
`@@ -1171,7 +1165,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {`
`1171`	`1165`	`matches!(param.kind, GenericParamKind::Lifetime { .. })`
`1172`	`1166`	`&& self.tcx.is_late_bound(param.hir_id)`
`1173`	`1167`	`})`
`1174`		`- .map(\|param\| late_arg_as_bound_arg(self.tcx, param))`
	`1168`	`+ .map(\|param\| late_arg_as_bound_arg(param))`
`1175`	`1169`	`.collect();`
`1176`	`1170`	`self.record_late_bound_vars(hir_id, binders);`
`1177`	`1171`	`let scope = Scope::Binder {`
Original file line number	Diff line number	Diff line change
`@@ -1050,7 +1050,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 't`
`1050`	`1050`	`}`
`1051`	`1051`	`ty::Bound(db, bt) if *db >= self.depth => {`
`1052`	`1052`	`self.vars.insert(match bt.kind {`
`1053`		`- ty::BoundTyKind::Param(def_id, _) => def_id,`
	`1053`	`+ ty::BoundTyKind::Param(def_id) => def_id,`
`1054`	`1054`	`ty::BoundTyKind::Anon => {`
`1055`	`1055`	`let reported = self`
`1056`	`1056`	`.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
`@@ -400,7 +400,7 @@ impl<'tcx> rustc_type_ir::inherent::BoundVarLike<TyCtxt<'tcx>> for BoundTy {`
`400`	`400`	`#[derive(HashStable)]`
`401`	`401`	`pub enum BoundTyKind {`
`402`	`402`	`Anon,`
`403`		`- Param(DefId, Symbol),`
	`403`	`+ Param(DefId),`
`404`	`404`	`}`
`405`	`405`
`406`	`406`	`impl From<BoundVar> for BoundTy {`
Original file line number	Diff line number	Diff line change
`@@ -291,14 +291,14 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind {`
`291`	`291`	`fn stable<'cx>(`
`292`	`292`	`&self,`
`293`	`293`	`tables: &mut Tables<'cx, BridgeTys>,`
`294`		`- _: &SmirCtxt<'cx, BridgeTys>,`
	`294`	`+ cx: &SmirCtxt<'cx, BridgeTys>,`
`295`	`295`	`) -> Self::T {`
`296`	`296`	`use stable_mir::ty::BoundTyKind;`
`297`	`297`
`298`	`298`	`match self {`
`299`	`299`	`ty::BoundTyKind::Anon => BoundTyKind::Anon,`
`300`		`- ty::BoundTyKind::Param(def_id, symbol) => {`
`301`		`- BoundTyKind::Param(tables.param_def(*def_id), symbol.to_string())`
	`300`	`+ ty::BoundTyKind::Param(def_id) => {`
	`301`	`+ BoundTyKind::Param(tables.param_def(def_id), cx.tcx.item_name(def_id).to_string())`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`	`}`