user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Give all impls a constness

Browse source
This commit is contained in:
Oli Scherer 2025-10-31 10:50:52 +00:00
parent 08c391ca09
commit 2a36d33930
19 changed files with 69 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

10
compiler/rustc_ast/src/ast.rs
View file

@ -3699,6 +3699,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>>,
@ -3708,7 +3709,6 @@ pub struct Impl {
pub struct TraitImplHeader {
pub defaultness: Defaultness,
pub safety: Safety,
pub constness: Const,
pub polarity: ImplPolarity,
pub trait_ref: TraitRef,
}
@ -4103,9 +4103,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);
@ -4116,7 +4116,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

6
compiler/rustc_ast/src/visit.rs
View file

@ -934,11 +934,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() });

9
compiler/rustc_ast_lowering/src/item.rs
View file

@ -344,6 +344,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:
@ -377,11 +378,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 {
@ -954,9 +958,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,
@ -979,7 +981,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
);
self.arena.alloc(hir::TraitImplHeader {
constness,
safety,
polarity,
defaultness,

11
compiler/rustc_ast_passes/src/ast_validation.rs
View file

@ -1070,14 +1070,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,
}) => {
@ -1109,7 +1104,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,

14
compiler/rustc_ast_pretty/src/pprust/state/item.rs
View file

@ -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,17 +321,12 @@ 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("!");
}
@ -339,6 +334,7 @@ impl<'a> State<'a> {
self.space();
self.word_space("for");
} else {
self.print_constness(*constness);
impl_generics(self);
}

4
compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
View file

@ -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(),
}),

6
compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
View file

@ -845,13 +845,9 @@ impl<'a> TraitDef<'a> {
safety: self.safety,
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(),
}),

4
compiler/rustc_expand/src/expand.rs
View file

@ -2386,10 +2386,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))
}
}

4
compiler/rustc_hir/src/hir.rs
View file

@ -4372,11 +4372,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,
@ -4948,7 +4948,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);

3
compiler/rustc_hir/src/intravisit.rs
View file

@ -594,10 +594,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: _,

2
compiler/rustc_hir/src/target.rs
View file

@ -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 {

4
compiler/rustc_hir_analysis/src/collect.rs
View file

@ -1346,7 +1346,7 @@ 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);
@ -1354,7 +1354,7 @@ fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> 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,
}
}

10
compiler/rustc_hir_pretty/src/lib.rs
View file

@ -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,

11
compiler/rustc_parse/src/parser/item.rs
View file

@ -665,13 +665,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 => {
@ -702,7 +697,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> {

12
compiler/rustc_passes/src/stability.rs
View file

@ -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.

3
src/tools/clippy/clippy_lints/src/derivable_impls.rs
View file

@ -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,

4
src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
View file

@ -495,12 +495,14 @@ 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)
@ -508,7 +510,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
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)

5
src/tools/rustfmt/src/items.rs
View file

@ -961,6 +961,7 @@ fn format_impl_ref_and_type(
of_trait,
self_ty,
items: _,
constness,
} = iimpl;
let mut result = String::with_capacity(128);
@ -969,6 +970,8 @@ fn format_impl_ref_and_type(
if let Some(of_trait) = of_trait.as_deref() {
result.push_str(format_defaultness(of_trait.defaultness));
result.push_str(format_safety(of_trait.safety));
} else {
result.push_str(format_constness_right(*constness));
}
let shape = if context.config.style_edition() >= StyleEdition::Edition2024 {
@ -985,7 +988,7 @@ fn format_impl_ref_and_type(
let trait_ref_overhead;
if let Some(of_trait) = of_trait.as_deref() {
result.push_str(format_constness_right(of_trait.constness));
result.push_str(format_constness_right(*constness));
let polarity_str = match of_trait.polarity {
ast::ImplPolarity::Negative(_) => "!",
ast::ImplPolarity::Positive => "",

18
tests/ui/stats/input-stats.stderr
View file

@ -2,14 +2,14 @@ ast-stats ================================================================
ast-stats POST EXPANSION AST STATS: input_stats
ast-stats Name Accumulated Size Count Item Size
ast-stats ----------------------------------------------------------------
ast-stats Item 1_496 (NN.N%) 11 136
ast-stats - Enum 136 (NN.N%) 1
ast-stats - ExternCrate 136 (NN.N%) 1
ast-stats - ForeignMod 136 (NN.N%) 1
ast-stats - Impl 136 (NN.N%) 1
ast-stats - Trait 136 (NN.N%) 1
ast-stats - Fn 272 (NN.N%) 2
ast-stats - Use 544 (NN.N%) 4
ast-stats Item 1_672 (NN.N%) 11 152
ast-stats - Enum 152 (NN.N%) 1
ast-stats - ExternCrate 152 (NN.N%) 1
ast-stats - ForeignMod 152 (NN.N%) 1
ast-stats - Impl 152 (NN.N%) 1
ast-stats - Trait 152 (NN.N%) 1
ast-stats - Fn 304 (NN.N%) 2
ast-stats - Use 608 (NN.N%) 4
ast-stats Ty 896 (NN.N%) 14 64
ast-stats - Ptr 64 (NN.N%) 1
ast-stats - Ref 64 (NN.N%) 1
@ -57,7 +57,7 @@ ast-stats GenericArgs 40 (NN.N%) 1 40
ast-stats - AngleBracketed 40 (NN.N%) 1
ast-stats Crate 40 (NN.N%) 1 40
ast-stats ----------------------------------------------------------------
ast-stats Total 7_440 129
ast-stats Total 7_616 129
ast-stats ================================================================
hir-stats ================================================================
hir-stats HIR STATS: input_stats