Give all impls a constness

oli-obk · oli-obk · commit c61304a1c90c · 2025-11-03T11:02:18.000Z
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -3687,6 +3687,7 @@ pub struct TyAlias {
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Impl {
     pub generics: Generics,
+    pub constness: Const,
     pub of_trait: Option<Box<TraitImplHeader>>,
     pub self_ty: Box<Ty>,
     pub items: ThinVec<Box<AssocItem>>,
@@ -3696,7 +3697,6 @@ pub struct Impl {
 pub struct TraitImplHeader {
     pub defaultness: Defaultness,
     pub safety: Safety,
-    pub constness: Const,
     pub polarity: ImplPolarity,
     pub trait_ref: TraitRef,
 }
@@ -4072,9 +4072,9 @@ mod size_asserts {
     static_assert_size!(GenericArg, 24);
     static_assert_size!(GenericBound, 88);
     static_assert_size!(Generics, 40);
-    static_assert_size!(Impl, 64);
-    static_assert_size!(Item, 136);
-    static_assert_size!(ItemKind, 72);
+    static_assert_size!(Impl, 80);
+    static_assert_size!(Item, 152);
+    static_assert_size!(ItemKind, 88);
     static_assert_size!(LitKind, 24);
     static_assert_size!(Local, 96);
     static_assert_size!(MetaItemLit, 40);
@@ -4085,7 +4085,7 @@ mod size_asserts {
     static_assert_size!(PathSegment, 24);
     static_assert_size!(Stmt, 32);
     static_assert_size!(StmtKind, 16);
-    static_assert_size!(TraitImplHeader, 80);
+    static_assert_size!(TraitImplHeader, 72);
     static_assert_size!(Ty, 64);
     static_assert_size!(TyKind, 40);
     // tidy-alphabetical-end
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -928,11 +928,11 @@ macro_rules! common_visitor_and_walkers {
         }
 
         impl_walkable!(|&$($mut)? $($lt)? self: Impl, vis: &mut V| {
-            let Impl { generics, of_trait, self_ty, items } = self;
+            let Impl { generics, of_trait, self_ty, items, constness: _ } = self;
             try_visit!(vis.visit_generics(generics));
             if let Some(box of_trait) = of_trait {
-                let TraitImplHeader { defaultness, safety, constness, polarity, trait_ref } = of_trait;
-                visit_visitable!($($mut)? vis, defaultness, safety, constness, polarity, trait_ref);
+                let TraitImplHeader { defaultness, safety, polarity, trait_ref } = of_trait;
+                visit_visitable!($($mut)? vis, defaultness, safety, polarity, trait_ref);
             }
             try_visit!(vis.visit_ty(self_ty));
             visit_visitable_with!($($mut)? vis, items, AssocCtxt::Impl { of_trait: of_trait.is_some() });
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -345,6 +345,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 of_trait,
                 self_ty: ty,
                 items: impl_items,
+                constness,
             }) => {
                 // Lower the "impl header" first. This ordering is important
                 // for in-band lifetimes! Consider `'a` here:
@@ -378,11 +379,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     .arena
                     .alloc_from_iter(impl_items.iter().map(|item| self.lower_impl_item_ref(item)));
 
+                let constness = self.lower_constness(*constness);
+
                 hir::ItemKind::Impl(hir::Impl {
                     generics,
                     of_trait,
                     self_ty: lowered_ty,
                     items: new_impl_items,
+                    constness,
                 })
             }
             ItemKind::Trait(box Trait {
@@ -970,9 +974,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         trait_impl_header: &TraitImplHeader,
     ) -> &'hir hir::TraitImplHeader<'hir> {
-        let TraitImplHeader { constness, safety, polarity, defaultness, ref trait_ref } =
-            *trait_impl_header;
-        let constness = self.lower_constness(constness);
+        let TraitImplHeader { safety, polarity, defaultness, ref trait_ref } = *trait_impl_header;
         let safety = self.lower_safety(safety, hir::Safety::Safe);
         let polarity = match polarity {
             ImplPolarity::Positive => ImplPolarity::Positive,
@@ -995,7 +997,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         );
 
         self.arena.alloc(hir::TraitImplHeader {
-            constness,
             safety,
             polarity,
             defaultness,
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1011,14 +1011,9 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
         match &item.kind {
             ItemKind::Impl(Impl {
                 generics,
+                constness,
                 of_trait:
-                    Some(box TraitImplHeader {
-                        safety,
-                        polarity,
-                        defaultness: _,
-                        constness,
-                        trait_ref: t,
-                    }),
+                    Some(box TraitImplHeader { safety, polarity, defaultness: _, trait_ref: t }),
                 self_ty,
                 items,
             }) => {
@@ -1050,7 +1045,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     walk_list!(this, visit_assoc_item, items, AssocCtxt::Impl { of_trait: true });
                 });
             }
-            ItemKind::Impl(Impl { generics, of_trait: None, self_ty, items }) => {
+            ItemKind::Impl(Impl { generics, of_trait: None, self_ty, items, constness: _ }) => {
                 self.visit_attrs_vis(&item.attrs, &item.vis);
                 self.visibility_not_permitted(
                     &item.vis,
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -305,7 +305,7 @@ impl<'a> State<'a> {
                 let (cb, ib) = self.head(visibility_qualified(&item.vis, "union"));
                 self.print_struct(struct_def, generics, *ident, item.span, true, cb, ib);
             }
-            ast::ItemKind::Impl(ast::Impl { generics, of_trait, self_ty, items }) => {
+            ast::ItemKind::Impl(ast::Impl { generics, of_trait, self_ty, items, constness }) => {
                 let (cb, ib) = self.head("");
                 self.print_visibility(&item.vis);
 
@@ -321,24 +321,20 @@ impl<'a> State<'a> {
                 };
 
                 if let Some(box of_trait) = of_trait {
-                    let ast::TraitImplHeader {
-                        defaultness,
-                        safety,
-                        constness,
-                        polarity,
-                        ref trait_ref,
-                    } = *of_trait;
+                    let ast::TraitImplHeader { defaultness, safety, polarity, ref trait_ref } =
+                        *of_trait;
                     self.print_defaultness(defaultness);
                     self.print_safety(safety);
                     impl_generics(self);
-                    self.print_constness(constness);
+                    self.print_constness(*constness);
                     if let ast::ImplPolarity::Negative(_) = polarity {
                         self.word("!");
                     }
                     self.print_trait_ref(trait_ref);
                     self.space();
                     self.word_space("for");
                 } else {
+                    self.print_constness(*constness);
                     impl_generics(self);
                 }
 
diff --git a/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs b/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
@@ -137,9 +137,9 @@ pub(crate) fn expand_deriving_coerce_pointee(
                         safety: ast::Safety::Default,
                         polarity: ast::ImplPolarity::Positive,
                         defaultness: ast::Defaultness::Final,
-                        constness: ast::Const::No,
                         trait_ref,
                     })),
+                    constness: ast::Const::No,
                     self_ty: self_type.clone(),
                     items: ThinVec::new(),
                 }),
@@ -160,9 +160,9 @@ pub(crate) fn expand_deriving_coerce_pointee(
                     safety: ast::Safety::Default,
                     polarity: ast::ImplPolarity::Positive,
                     defaultness: ast::Defaultness::Final,
-                    constness: ast::Const::No,
                     trait_ref,
                 })),
+                constness: ast::Const::No,
                 self_ty: self_type.clone(),
                 items: ThinVec::new(),
             }),
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -835,13 +835,9 @@ impl<'a> TraitDef<'a> {
                     safety: ast::Safety::Default,
                     polarity: ast::ImplPolarity::Positive,
                     defaultness: ast::Defaultness::Final,
-                    constness: if self.is_const {
-                        ast::Const::Yes(DUMMY_SP)
-                    } else {
-                        ast::Const::No
-                    },
                     trait_ref,
                 })),
+                constness: if self.is_const { ast::Const::Yes(DUMMY_SP) } else { ast::Const::No },
                 self_ty: self_type,
                 items: methods.into_iter().chain(associated_types).collect(),
             }),
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
@@ -2389,10 +2389,10 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
     ) -> SmallVec<[Box<ast::AssocItem>; 1]> {
         match ctxt {
             AssocCtxt::Trait => self.flat_map_node(AstNodeWrapper::new(node, TraitItemTag)),
-            AssocCtxt::Impl { of_trait: false } => {
+            AssocCtxt::Impl { of_trait: false, .. } => {
                 self.flat_map_node(AstNodeWrapper::new(node, ImplItemTag))
             }
-            AssocCtxt::Impl { of_trait: true } => {
+            AssocCtxt::Impl { of_trait: true, .. } => {
                 self.flat_map_node(AstNodeWrapper::new(node, TraitImplItemTag))
             }
         }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -4345,11 +4345,11 @@ pub struct Impl<'hir> {
     pub of_trait: Option<&'hir TraitImplHeader<'hir>>,
     pub self_ty: &'hir Ty<'hir>,
     pub items: &'hir [ImplItemId],
+    pub constness: Constness,
 }
 
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct TraitImplHeader<'hir> {
-    pub constness: Constness,
     pub safety: Safety,
     pub polarity: ImplPolarity,
     pub defaultness: Defaultness,
@@ -4914,7 +4914,7 @@ mod size_asserts {
     static_assert_size!(GenericArg<'_>, 16);
     static_assert_size!(GenericBound<'_>, 64);
     static_assert_size!(Generics<'_>, 56);
-    static_assert_size!(Impl<'_>, 40);
+    static_assert_size!(Impl<'_>, 48);
     static_assert_size!(ImplItem<'_>, 88);
     static_assert_size!(ImplItemKind<'_>, 40);
     static_assert_size!(Item<'_>, 88);
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -590,10 +590,9 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
             try_visit!(visitor.visit_generics(generics));
             try_visit!(visitor.visit_enum_def(enum_definition));
         }
-        ItemKind::Impl(Impl { generics, of_trait, self_ty, items }) => {
+        ItemKind::Impl(Impl { generics, of_trait, self_ty, items, constness: _ }) => {
             try_visit!(visitor.visit_generics(generics));
             if let Some(TraitImplHeader {
-                constness: _,
                 safety: _,
                 polarity: _,
                 defaultness: _,
diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
@@ -240,7 +240,7 @@ impl Target {
             AssocItemKind::Const(_) => Target::AssocConst,
             AssocItemKind::Fn(f) => Target::Method(match assoc_ctxt {
                 AssocCtxt::Trait => MethodKind::Trait { body: f.body.is_some() },
-                AssocCtxt::Impl { of_trait } => {
+                AssocCtxt::Impl { of_trait, .. } => {
                     if of_trait {
                         MethodKind::TraitImpl
                     } else {
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1301,15 +1301,15 @@ fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplTraitHeader
     let selfty = tcx.type_of(def_id).instantiate_identity();
     let is_rustc_reservation = tcx.has_attr(def_id, sym::rustc_reservation_impl);
 
-    check_impl_constness(tcx, of_trait.constness, &of_trait.trait_ref);
+    check_impl_constness(tcx, impl_.constness, &of_trait.trait_ref);
 
     let trait_ref = icx.lowerer().lower_impl_trait_ref(&of_trait.trait_ref, selfty);
 
     ty::ImplTraitHeader {
         trait_ref: ty::EarlyBinder::bind(trait_ref),
         safety: of_trait.safety,
         polarity: polarity_of_impl(tcx, of_trait, is_rustc_reservation),
-        constness: of_trait.constness,
+        constness: impl_.constness,
     }
 }
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -690,7 +690,7 @@ impl<'a> State<'a> {
                 let (cb, ib) = self.head("union");
                 self.print_struct(ident.name, generics, struct_def, item.span, true, cb, ib);
             }
-            hir::ItemKind::Impl(hir::Impl { generics, of_trait, self_ty, items }) => {
+            hir::ItemKind::Impl(hir::Impl { generics, of_trait, self_ty, items, constness }) => {
                 let (cb, ib) = self.head("");
 
                 let impl_generics = |this: &mut Self| {
@@ -702,9 +702,13 @@ impl<'a> State<'a> {
                 };
 
                 match of_trait {
-                    None => impl_generics(self),
+                    None => {
+                        if let hir::Constness::Const = constness {
+                            self.word_nbsp("const");
+                        }
+                        impl_generics(self)
+                    }
                     Some(&hir::TraitImplHeader {
-                        constness,
                         safety,
                         polarity,
                         defaultness,
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -662,13 +662,8 @@ impl<'a> Parser<'a> {
                 };
                 let trait_ref = TraitRef { path, ref_id: ty_first.id };
 
-                let of_trait = Some(Box::new(TraitImplHeader {
-                    defaultness,
-                    safety,
-                    constness,
-                    polarity,
-                    trait_ref,
-                }));
+                let of_trait =
+                    Some(Box::new(TraitImplHeader { defaultness, safety, polarity, trait_ref }));
                 (of_trait, ty_second)
             }
             None => {
@@ -699,7 +694,7 @@ impl<'a> Parser<'a> {
             }
         };
 
-        Ok(ItemKind::Impl(Impl { generics, of_trait, self_ty, items: impl_items }))
+        Ok(ItemKind::Impl(Impl { generics, of_trait, self_ty, items: impl_items, constness }))
     }
 
     fn parse_item_delegation(&mut self) -> PResult<'a, ItemKind> {
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
@@ -589,7 +589,13 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
             // For implementations of traits, check the stability of each item
             // individually as it's possible to have a stable trait with unstable
             // items.
-            hir::ItemKind::Impl(hir::Impl { of_trait: Some(of_trait), self_ty, items, .. }) => {
+            hir::ItemKind::Impl(hir::Impl {
+                of_trait: Some(of_trait),
+                self_ty,
+                items,
+                constness,
+                ..
+            }) => {
                 let features = self.tcx.features();
                 if features.staged_api() {
                     let attrs = self.tcx.hir_attrs(item.hir_id());
@@ -652,7 +658,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     }
 
                     if features.const_trait_impl()
-                        && let hir::Constness::Const = of_trait.constness
+                        && let hir::Constness::Const = constness
                     {
                         let stable_or_implied_stable = match const_stab {
                             None => true,
@@ -696,7 +702,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     }
                 }
 
-                if let hir::Constness::Const = of_trait.constness
+                if let hir::Constness::Const = constness
                     && let Some(def_id) = of_trait.trait_ref.trait_def_id()
                 {
                     // FIXME(const_trait_impl): Improve the span here.
diff --git a/src/tools/clippy/clippy_lints/src/derivable_impls.rs b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
@@ -232,6 +232,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             of_trait: Some(of_trait),
             items: [child],
             self_ty,
+            constness,
             ..
         }) = item.kind
             && !cx.tcx.is_automatically_derived(item.owner_id.to_def_id())
@@ -247,7 +248,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             && !attrs.iter().any(|attr| attr.doc_str().is_some())
             && cx.tcx.hir_attrs(impl_item_hir).is_empty()
         {
-            let is_const = of_trait.constness == hir::Constness::Const;
+            let is_const = constness == hir::Constness::Const;
             if adt_def.is_struct() {
                 check_struct(
                     cx,
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
@@ -496,20 +496,22 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 of_trait: lot,
                 self_ty: lst,
                 items: li,
+                constness: lc,
             }),
             Impl(ast::Impl {
                 generics: rg,
                 of_trait: rot,
                 self_ty: rst,
                 items: ri,
+                constness: rc,
             }),
         ) => {
             eq_generics(lg, rg)
                 && both(lot.as_deref(), rot.as_deref(), |l, r| {
                     matches!(l.safety, Safety::Default) == matches!(r.safety, Safety::Default)
                         && matches!(l.polarity, ImplPolarity::Positive) == matches!(r.polarity, ImplPolarity::Positive)
                         && eq_defaultness(l.defaultness, r.defaultness)
-                        && matches!(l.constness, ast::Const::No) == matches!(r.constness, ast::Const::No)
+                        && matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
                         && eq_path(&l.trait_ref.path, &r.trait_ref.path)
                 })
                 && eq_ty(lst, rst)
diff --git a/src/tools/rustfmt/src/items.rs b/src/tools/rustfmt/src/items.rs
diff --git a/tests/ui/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr

Original file line number	Diff line number	Diff line change
`@@ -928,11 +928,11 @@ macro_rules! common_visitor_and_walkers {`
`928`	`928`	`}`
`929`	`929`
`930`	`930`	`impl_walkable!(\|&$($mut)? $($lt)? self: Impl, vis: &mut V\| {`
`931`		`- let Impl { generics, of_trait, self_ty, items } = self;`
	`931`	`+ let Impl { generics, of_trait, self_ty, items, constness: _ } = self;`
`932`	`932`	`try_visit!(vis.visit_generics(generics));`
`933`	`933`	`if let Some(box of_trait) = of_trait {`
`934`		`- let TraitImplHeader { defaultness, safety, constness, polarity, trait_ref } = of_trait;`
`935`		`- visit_visitable!($($mut)? vis, defaultness, safety, constness, polarity, trait_ref);`
	`934`	`+ let TraitImplHeader { defaultness, safety, polarity, trait_ref } = of_trait;`
	`935`	`+ visit_visitable!($($mut)? vis, defaultness, safety, polarity, trait_ref);`
`936`	`936`	`}`
`937`	`937`	`try_visit!(vis.visit_ty(self_ty));`
`938`	`938`	`visit_visitable_with!($($mut)? vis, items, AssocCtxt::Impl { of_trait: of_trait.is_some() });`
Original file line number	Diff line number	Diff line change
`@@ -2389,10 +2389,10 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {`
`2389`	`2389`	`) -> SmallVec<[Box<ast::AssocItem>; 1]> {`
`2390`	`2390`	`match ctxt {`
`2391`	`2391`	`AssocCtxt::Trait => self.flat_map_node(AstNodeWrapper::new(node, TraitItemTag)),`
`2392`		`- AssocCtxt::Impl { of_trait: false } => {`
	`2392`	`+ AssocCtxt::Impl { of_trait: false, .. } => {`
`2393`	`2393`	`self.flat_map_node(AstNodeWrapper::new(node, ImplItemTag))`
`2394`	`2394`	`}`
`2395`		`- AssocCtxt::Impl { of_trait: true } => {`
	`2395`	`+ AssocCtxt::Impl { of_trait: true, .. } => {`
`2396`	`2396`	`self.flat_map_node(AstNodeWrapper::new(node, TraitImplItemTag))`
`2397`	`2397`	`}`
`2398`	`2398`	`}`