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

Extract ast TraitImplHeader

Browse source
This commit is contained in:
Cameron Steffen 2025-07-21 20:05:16 -05:00
parent 3aa0ac0a8a
commit 5bc23ce255
18 changed files with 187 additions and 184 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -3661,17 +3661,21 @@ pub struct TyAlias {
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct Impl {
pub defaultness: Defaultness,
pub safety: Safety,
pub generics: Generics,
pub constness: Const,
pub polarity: ImplPolarity,
/// The trait being implemented, if any.
pub of_trait: Option<TraitRef>,
pub of_trait: Option<Box<TraitImplHeader>>,
pub self_ty: Box<Ty>,
pub items: ThinVec<Box<AssocItem>>,
}
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct TraitImplHeader {
pub defaultness: Defaultness,
pub safety: Safety,
pub constness: Const,
pub polarity: ImplPolarity,
pub trait_ref: TraitRef,
}
#[derive(Clone, Encodable, Decodable, Debug, Default, Walkable)]
pub struct FnContract {
pub requires: Option<Box<Expr>>,
@ -3793,7 +3797,7 @@ pub enum ItemKind {
/// An implementation.
///
/// E.g., `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`.
Impl(Box<Impl>),
Impl(Impl),
/// A macro invocation.
///
/// E.g., `foo!(..)`.
@ -3880,7 +3884,7 @@ impl ItemKind {
| Self::Union(_, generics, _)
| Self::Trait(box Trait { generics, .. })
| Self::TraitAlias(_, generics, _)
| Self::Impl(box Impl { generics, .. }) => Some(generics),
| Self::Impl(Impl { generics, .. }) => Some(generics),
_ => None,
}
}
@ -4040,7 +4044,7 @@ mod size_asserts {
static_assert_size!(GenericArg, 24);
static_assert_size!(GenericBound, 88);
static_assert_size!(Generics, 40);
static_assert_size!(Impl, 136);
static_assert_size!(Impl, 64);
static_assert_size!(Item, 144);
static_assert_size!(ItemKind, 80);
static_assert_size!(LitKind, 24);
@ -4053,6 +4057,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!(Ty, 64);
static_assert_size!(TyKind, 40);
// tidy-alphabetical-end

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

@ -929,8 +929,13 @@ macro_rules! common_visitor_and_walkers {
}
impl_walkable!(|&$($mut)? $($lt)? self: Impl, vis: &mut V| {
let Impl { defaultness, safety, generics, constness, polarity, of_trait, self_ty, items } = self;
visit_visitable!($($mut)? vis, defaultness, safety, generics, constness, polarity, of_trait, self_ty);
let Impl { generics, of_trait, self_ty, items } = 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);
}
try_visit!(vis.visit_ty(self_ty));
visit_visitable_with!($($mut)? vis, items, AssocCtxt::Impl { of_trait: of_trait.is_some() });
V::Result::output()
});

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

@ -340,13 +340,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
);
hir::ItemKind::Union(ident, generics, vdata)
}
ItemKind::Impl(box Impl {
safety,
polarity,
defaultness,
constness,
ItemKind::Impl(Impl {
generics: ast_generics,
of_trait: trait_ref,
of_trait,
self_ty: ty,
items: impl_items,
}) => {
@ -373,10 +369,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
polarity: BoundPolarity::Positive,
};
let trait_ref = trait_ref.as_ref().map(|trait_ref| {
let trait_ref = of_trait.as_ref().map(|of_trait| {
this.lower_trait_ref(
modifiers,
trait_ref,
&of_trait.trait_ref,
ImplTraitContext::Disallowed(ImplTraitPosition::Trait),
)
});
@ -396,14 +392,35 @@ impl<'hir> LoweringContext<'_, 'hir> {
// `defaultness.has_value()` is never called for an `impl`, always `true` in order
// to not cause an assertion failure inside the `lower_defaultness` function.
let has_val = true;
let (defaultness, defaultness_span) = self.lower_defaultness(*defaultness, has_val);
let polarity = match polarity {
ImplPolarity::Positive => ImplPolarity::Positive,
ImplPolarity::Negative(s) => ImplPolarity::Negative(self.lower_span(*s)),
let (constness, safety, polarity, defaultness, defaultness_span) = match *of_trait {
Some(box TraitImplHeader {
constness,
safety,
polarity,
defaultness,
trait_ref: _,
}) => {
let constness = self.lower_constness(constness);
let safety = self.lower_safety(safety, hir::Safety::Safe);
let polarity = match polarity {
ImplPolarity::Positive => ImplPolarity::Positive,
ImplPolarity::Negative(s) => ImplPolarity::Negative(self.lower_span(s)),
};
let (defaultness, defaultness_span) =
self.lower_defaultness(defaultness, has_val);
(constness, safety, polarity, defaultness, defaultness_span)
}
None => (
hir::Constness::NotConst,
hir::Safety::Safe,
ImplPolarity::Positive,
hir::Defaultness::Final,
None,
),
};
hir::ItemKind::Impl(self.arena.alloc(hir::Impl {
constness: self.lower_constness(*constness),
safety: self.lower_safety(*safety, hir::Safety::Safe),
constness,
safety,
polarity,
defaultness,
defaultness_span,

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

@ -954,13 +954,16 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
match &item.kind {
ItemKind::Impl(box Impl {
safety,
polarity,
defaultness: _,
constness,
ItemKind::Impl(Impl {
generics,
of_trait: Some(t),
of_trait:
Some(box TraitImplHeader {
safety,
polarity,
defaultness: _,
constness,
trait_ref: t,
}),
self_ty,
items,
}) => {
@ -992,16 +995,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
walk_list!(this, visit_assoc_item, items, AssocCtxt::Impl { of_trait: true });
});
}
ItemKind::Impl(box Impl {
safety: _,
polarity: _,
defaultness: _,
constness: _,
generics,
of_trait: None,
self_ty,
items,
}) => {
ItemKind::Impl(Impl { generics, of_trait: None, self_ty, items }) => {
self.visit_attrs_vis(&item.attrs, &item.vis);
self.visibility_not_permitted(
&item.vis,

8
compiler/rustc_ast_passes/src/feature_gate.rs
View file

@ -217,18 +217,18 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
}
}
ast::ItemKind::Impl(box ast::Impl { polarity, defaultness, of_trait, .. }) => {
if let &ast::ImplPolarity::Negative(span) = polarity {
ast::ItemKind::Impl(ast::Impl { of_trait: Some(of_trait), .. }) => {
if let ast::ImplPolarity::Negative(span) = of_trait.polarity {
gate!(
&self,
negative_impls,
span.to(of_trait.as_ref().map_or(span, |t| t.path.span)),
span.to(of_trait.trait_ref.path.span),
"negative trait bounds are not fully implemented; \
use marker types for now"
);
}
if let ast::Defaultness::Default(_) = defaultness {
if let ast::Defaultness::Default(_) = of_trait.defaultness {
gate!(&self, specialization, i.span, "specialization is unstable");
}
}

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

@ -308,39 +308,41 @@ 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(box ast::Impl {
safety,
polarity,
defaultness,
constness,
generics,
of_trait,
self_ty,
items,
}) => {
ast::ItemKind::Impl(ast::Impl { generics, of_trait, self_ty, items }) => {
let (cb, ib) = self.head("");
self.print_visibility(&item.vis);
self.print_defaultness(*defaultness);
self.print_safety(*safety);
self.word("impl");
if generics.params.is_empty() {
self.nbsp();
} else {
self.print_generic_params(&generics.params);
self.space();
}
let impl_generics = |this: &mut Self| {
this.word("impl");
self.print_constness(*constness);
if generics.params.is_empty() {
this.nbsp();
} else {
this.print_generic_params(&generics.params);
this.space();
}
};
if let ast::ImplPolarity::Negative(_) = polarity {
self.word("!");
}
if let Some(t) = of_trait {
self.print_trait_ref(t);
if let Some(box of_trait) = of_trait {
let ast::TraitImplHeader {
defaultness,
safety,
constness,
polarity,
ref trait_ref,
} = *of_trait;
self.print_defaultness(defaultness);
self.print_safety(safety);
impl_generics(self);
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 {
impl_generics(self);
}
self.print_type(self_ty);

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

@ -108,11 +108,7 @@ pub(crate) fn expand_deriving_coerce_pointee(
cx.item(
span,
attrs.clone(),
ast::ItemKind::Impl(Box::new(ast::Impl {
safety: ast::Safety::Default,
polarity: ast::ImplPolarity::Positive,
defaultness: ast::Defaultness::Final,
constness: ast::Const::No,
ast::ItemKind::Impl(ast::Impl {
generics: Generics {
params: generics
.params
@ -137,10 +133,16 @@ pub(crate) fn expand_deriving_coerce_pointee(
where_clause: generics.where_clause.clone(),
span: generics.span,
},
of_trait: Some(trait_ref),
of_trait: Some(Box::new(ast::TraitImplHeader {
safety: ast::Safety::Default,
polarity: ast::ImplPolarity::Positive,
defaultness: ast::Defaultness::Final,
constness: ast::Const::No,
trait_ref,
})),
self_ty: self_type.clone(),
items: ThinVec::new(),
})),
}),
),
));
}
@ -152,16 +154,18 @@ pub(crate) fn expand_deriving_coerce_pointee(
let item = cx.item(
span,
attrs.clone(),
ast::ItemKind::Impl(Box::new(ast::Impl {
safety: ast::Safety::Default,
polarity: ast::ImplPolarity::Positive,
defaultness: ast::Defaultness::Final,
constness: ast::Const::No,
ast::ItemKind::Impl(ast::Impl {
generics,
of_trait: Some(trait_ref),
of_trait: Some(Box::new(ast::TraitImplHeader {
safety: ast::Safety::Default,
polarity: ast::ImplPolarity::Positive,
defaultness: ast::Defaultness::Final,
constness: ast::Const::No,
trait_ref,
})),
self_ty: self_type.clone(),
items: ThinVec::new(),
})),
}),
);
push(Annotatable::Item(item));
};

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

@ -826,21 +826,25 @@ impl<'a> TraitDef<'a> {
)
}
let opt_trait_ref = Some(trait_ref);
cx.item(
self.span,
attrs,
ast::ItemKind::Impl(Box::new(ast::Impl {
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 },
ast::ItemKind::Impl(ast::Impl {
generics: trait_generics,
of_trait: opt_trait_ref,
of_trait: Some(Box::new(ast::TraitImplHeader {
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,
})),
self_ty: self_type,
items: methods.into_iter().chain(associated_types).collect(),
})),
}),
)
}

5
compiler/rustc_lint/src/builtin.rs
View file

@ -270,7 +270,10 @@ impl EarlyLintPass for UnsafeCode {
self.report_unsafe(cx, it.span, BuiltinUnsafe::UnsafeTrait);
}
ast::ItemKind::Impl(box ast::Impl { safety: ast::Safety::Unsafe(_), .. }) => {
ast::ItemKind::Impl(ast::Impl {
of_trait: Some(box ast::TraitImplHeader { safety: ast::Safety::Unsafe(_), .. }),
..
}) => {
self.report_unsafe(cx, it.span, BuiltinUnsafe::UnsafeImpl);
}

8
compiler/rustc_lint/src/internal.rs
View file

@ -411,11 +411,11 @@ declare_lint_pass!(LintPassImpl => [LINT_PASS_IMPL_WITHOUT_MACRO]);
impl EarlyLintPass for LintPassImpl {
fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
if let ast::ItemKind::Impl(box ast::Impl { of_trait: Some(lint_pass), .. }) = &item.kind
&& let Some(last) = lint_pass.path.segments.last()
if let ast::ItemKind::Impl(ast::Impl { of_trait: Some(of_trait), .. }) = &item.kind
&& let Some(last) = of_trait.trait_ref.path.segments.last()
&& last.ident.name == sym::LintPass
{
let expn_data = lint_pass.path.span.ctxt().outer_expn_data();
let expn_data = of_trait.trait_ref.path.span.ctxt().outer_expn_data();
let call_site = expn_data.call_site;
if expn_data.kind != ExpnKind::Macro(MacroKind::Bang, sym::impl_lint_pass)
&& call_site.ctxt().outer_expn_data().kind
@ -423,7 +423,7 @@ impl EarlyLintPass for LintPassImpl {
{
cx.emit_span_lint(
LINT_PASS_IMPL_WITHOUT_MACRO,
lint_pass.path.span,
of_trait.trait_ref.path.span,
LintPassByHand,
);
}

2
compiler/rustc_lint/src/nonstandard_style.rs
View file

@ -187,7 +187,7 @@ impl EarlyLintPass for NonCamelCaseTypes {
// N.B. This check is only for inherent associated types, so that we don't lint against
// trait impls where we should have warned for the trait definition already.
ast::ItemKind::Impl(box ast::Impl { of_trait: None, items, .. }) => {
ast::ItemKind::Impl(ast::Impl { of_trait: None, items, .. }) => {
for it in items {
// FIXME: this doesn't respect `#[allow(..)]` on the item itself.
if let ast::AssocItemKind::Type(alias) = &it.kind {

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

@ -663,7 +663,14 @@ impl<'a> Parser<'a> {
};
let trait_ref = TraitRef { path, ref_id: ty_first.id };
(Some(trait_ref), ty_second)
let of_trait = Some(Box::new(TraitImplHeader {
defaultness,
safety,
constness,
polarity,
trait_ref,
}));
(of_trait, ty_second)
}
None => {
let self_ty = ty_first;
@ -692,16 +699,8 @@ impl<'a> Parser<'a> {
(None, self_ty)
}
};
Ok(ItemKind::Impl(Box::new(Impl {
safety,
polarity,
defaultness,
constness,
generics,
of_trait,
self_ty,
items: impl_items,
})))
Ok(ItemKind::Impl(Impl { generics, of_trait, self_ty, items: impl_items }))
}
fn parse_item_delegation(&mut self) -> PResult<'a, ItemKind> {
@ -1389,10 +1388,10 @@ impl<'a> Parser<'a> {
};
match &mut item_kind {
ItemKind::Impl(box Impl { of_trait: Some(trai), constness, .. }) => {
*constness = Const::Yes(const_span);
ItemKind::Impl(Impl { of_trait: Some(of_trait), .. }) => {
of_trait.constness = Const::Yes(const_span);
let before_trait = trai.path.span.shrink_to_lo();
let before_trait = of_trait.trait_ref.path.span.shrink_to_lo();
let const_up_to_impl = const_span.with_hi(impl_span.lo());
err.with_multipart_suggestion(
"you might have meant to write a const trait impl",

7
compiler/rustc_resolve/src/build_reduced_graph.rs
View file

@ -11,7 +11,7 @@ use std::sync::Arc;
use rustc_ast::visit::{self, AssocCtxt, Visitor, WalkItemKind};
use rustc_ast::{
self as ast, AssocItem, AssocItemKind, Block, ConstItem, Delegation, Fn, ForeignItem,
ForeignItemKind, Impl, Item, ItemKind, NodeId, StaticItem, StmtKind, TyAlias,
ForeignItemKind, Item, ItemKind, NodeId, StaticItem, StmtKind, TyAlias,
};
use rustc_attr_parsing as attr;
use rustc_attr_parsing::AttributeParser;
@ -906,10 +906,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
}
// These items do not add names to modules.
ItemKind::Impl(box Impl { of_trait: Some(..), .. })
| ItemKind::Impl { .. }
| ItemKind::ForeignMod(..)
| ItemKind::GlobalAsm(..) => {}
ItemKind::Impl { .. } | ItemKind::ForeignMod(..) | ItemKind::GlobalAsm(..) => {}
ItemKind::MacroDef(..) | ItemKind::MacCall(_) | ItemKind::DelegationMac(..) => {
unreachable!()

14
compiler/rustc_resolve/src/late.rs
View file

@ -2620,7 +2620,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
self.resolve_adt(item, generics);
}
ItemKind::Impl(box Impl {
ItemKind::Impl(Impl {
ref generics,
ref of_trait,
ref self_ty,
@ -2631,7 +2631,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
self.resolve_implementation(
&item.attrs,
generics,
of_trait,
of_trait.as_deref(),
self_ty,
item.id,
impl_items,
@ -3177,7 +3177,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
&mut self,
attrs: &[ast::Attribute],
generics: &'ast Generics,
opt_trait_reference: &'ast Option<TraitRef>,
of_trait: Option<&'ast ast::TraitImplHeader>,
self_type: &'ast Ty,
item_id: NodeId,
impl_items: &'ast [Box<AssocItem>],
@ -3201,7 +3201,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|this| {
// Resolve the trait reference, if necessary.
this.with_optional_trait_ref(
opt_trait_reference.as_ref(),
of_trait.map(|t| &t.trait_ref),
self_type,
|this, trait_id| {
this.resolve_doc_links(attrs, MaybeExported::Impl(trait_id));
@ -3224,9 +3224,9 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
is_trait_impl: trait_id.is_some()
};
this.with_self_rib(res, |this| {
if let Some(trait_ref) = opt_trait_reference.as_ref() {
if let Some(of_trait) = of_trait {
// Resolve type arguments in the trait path.
visit::walk_trait_ref(this, trait_ref);
visit::walk_trait_ref(this, &of_trait.trait_ref);
}
// Resolve the self type.
this.visit_ty(self_type);
@ -5183,7 +5183,7 @@ impl<'ast> Visitor<'ast> for ItemInfoCollector<'_, '_, '_> {
| ItemKind::Enum(_, generics, _)
| ItemKind::Struct(_, generics, _)
| ItemKind::Union(_, generics, _)
| ItemKind::Impl(box Impl { generics, .. })
| ItemKind::Impl(Impl { generics, .. })
| ItemKind::Trait(box Trait { generics, .. })
| ItemKind::TraitAlias(_, generics, _) => {
if let ItemKind::Fn(box Fn { sig, .. }) = &item.kind {

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

@ -473,33 +473,27 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
eq_id(*li, *ri) && eq_generics(lg, rg) && over(lb, rb, eq_generic_bound)
},
(
Impl(box ast::Impl {
safety: lu,
polarity: lp,
defaultness: ld,
constness: lc,
Impl(ast::Impl {
generics: lg,
of_trait: lot,
self_ty: lst,
items: li,
}),
Impl(box ast::Impl {
safety: ru,
polarity: rp,
defaultness: rd,
constness: rc,
Impl(ast::Impl {
generics: rg,
of_trait: rot,
self_ty: rst,
items: ri,
}),
) => {
matches!(lu, Safety::Default) == matches!(ru, Safety::Default)
&& matches!(lp, ImplPolarity::Positive) == matches!(rp, ImplPolarity::Positive)
&& eq_defaultness(*ld, *rd)
&& matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
&& eq_generics(lg, rg)
&& both(lot.as_ref(), rot.as_ref(), |l, r| eq_path(&l.path, &r.path))
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)
&& eq_path(&l.trait_ref.path, &r.trait_ref.path)
})
&& eq_ty(lst, rst)
&& over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
},

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

@ -958,20 +958,19 @@ fn format_impl_ref_and_type(
offset: Indent,
) -> Option<String> {
let ast::Impl {
safety,
polarity,
defaultness,
constness,
ref generics,
of_trait: ref trait_ref,
ref self_ty,
..
} = *iimpl;
generics,
of_trait,
self_ty,
items: _,
} = iimpl;
let mut result = String::with_capacity(128);
result.push_str(&format_visibility(context, &item.vis));
result.push_str(format_defaultness(defaultness));
result.push_str(format_safety(safety));
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));
}
let shape = if context.config.style_edition() >= StyleEdition::Edition2024 {
Shape::indented(offset + last_line_width(&result), context.config)
@ -984,28 +983,24 @@ fn format_impl_ref_and_type(
};
let generics_str = rewrite_generics(context, "impl", generics, shape).ok()?;
result.push_str(&generics_str);
result.push_str(format_constness_right(constness));
let polarity_str = match polarity {
ast::ImplPolarity::Negative(_) => "!",
ast::ImplPolarity::Positive => "",
};
let polarity_overhead;
let trait_ref_overhead;
if let Some(ref trait_ref) = *trait_ref {
if let Some(of_trait) = of_trait.as_deref() {
result.push_str(format_constness_right(of_trait.constness));
let polarity_str = match of_trait.polarity {
ast::ImplPolarity::Negative(_) => "!",
ast::ImplPolarity::Positive => "",
};
let result_len = last_line_width(&result);
result.push_str(&rewrite_trait_ref(
context,
trait_ref,
&of_trait.trait_ref,
offset,
polarity_str,
result_len,
)?);
polarity_overhead = 0; // already written
trait_ref_overhead = " for".len();
} else {
polarity_overhead = polarity_str.len();
trait_ref_overhead = 0;
}
@ -1020,17 +1015,15 @@ fn format_impl_ref_and_type(
} else {
0
};
let used_space =
last_line_width(&result) + polarity_overhead + trait_ref_overhead + curly_brace_overhead;
let used_space = last_line_width(&result) + trait_ref_overhead + curly_brace_overhead;
// 1 = space before the type.
let budget = context.budget(used_space + 1);
if let Some(self_ty_str) = self_ty.rewrite(context, Shape::legacy(budget, offset)) {
if !self_ty_str.contains('\n') {
if trait_ref.is_some() {
if of_trait.is_some() {
result.push_str(" for ");
} else {
result.push(' ');
result.push_str(polarity_str);
}
result.push_str(&self_ty_str);
return Some(result);
@ -1042,12 +1035,10 @@ fn format_impl_ref_and_type(
// Add indentation of one additional tab.
let new_line_offset = offset.block_indent(context.config);
result.push_str(&new_line_offset.to_string(context.config));
if trait_ref.is_some() {
if of_trait.is_some() {
result.push_str("for ");
} else {
result.push_str(polarity_str);
}
let budget = context.budget(last_line_width(&result) + polarity_overhead);
let budget = context.budget(last_line_width(&result));
let type_offset = match context.config.indent_style() {
IndentStyle::Visual => new_line_offset + trait_ref_overhead,
IndentStyle::Block => new_line_offset,

4
src/tools/rustfmt/tests/source/negative-impl.rs
View file

@ -1,7 +1,3 @@
impl ! Display for JoinHandle { }
impl ! Box < JoinHandle > { }
impl ! std :: fmt :: Display for JoinHandle < T : std :: future :: Future + std :: marker :: Send + std :: marker :: Sync > { }
impl ! JoinHandle < T : std :: future :: Future < Output > + std :: marker :: Send + std :: marker :: Sync + 'static > + 'static { }

8
src/tools/rustfmt/tests/target/negative-impl.rs
View file

@ -1,14 +1,6 @@
impl !Display for JoinHandle {}
impl !Box<JoinHandle> {}
impl !std::fmt::Display
for JoinHandle<T: std::future::Future + std::marker::Send + std::marker::Sync>
{
}
impl
!JoinHandle<T: std::future::Future<Output> + std::marker::Send + std::marker::Sync + 'static>
+ 'static
{
}