Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Use a lookup table in #[derive(Debug)] for fieldless enums #114190

Closed
wants to merge 1 commit into from
Closed

Use a lookup table in #[derive(Debug)] for fieldless enums #114190

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
29 changes: 19 additions & 10 deletions compiler/rustc_builtin_macros/src/deriving/debug.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -197,15 +197,18 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
}

/// Special case for enums with no fields. Builds:
///
/// ```text
/// impl ::core::fmt::Debug for A {
/// impl ::core::fmt::Debug for Fieldless {
/// fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
/// ::core::fmt::Formatter::write_str(f,
/// match self {
/// A::A => "A",
/// A::B() => "B",
/// A::C {} => "C",
/// })
/// ::core::fmt::Formatter::write_str(
/// f,
/// const { ["A", "B", "C"] }[match self {
/// Fieldless::A => 0usize,
/// Fieldless::B => 1usize,
/// Fieldless::C => 2usize,
/// }],
Comment on lines +206 to +210
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I have been looking into a similar case recently as noted in #114106 (comment), and part of the problem might be the match statement itself.

For data-less enums with dense/contiguous discriminants, you should be able to just use something like *self as u32 to use the discriminant directly as an index instead of via the match roundtrip.

/// )
/// }
/// }
/// ```
Expand All @@ -216,10 +219,14 @@ fn show_fieldless_enum(
substr: &Substructure<'_>,
) -> BlockOrExpr {
let fmt = substr.nonselflike_args[0].clone();

let strs = def.variants.iter().map(|v| cx.expr_str(span, v.ident.name)).collect();
let array = cx.expr_const_block(span, cx.block_expr(cx.expr_array(span, strs)));
let arms = def
.variants
.iter()
.map(|v| {
.enumerate()
.map(|(i, v)| {
let variant_path = cx.path(span, vec![substr.type_ident, v.ident]);
let pat = match &v.data {
ast::VariantData::Tuple(fields, _) => {
Expand All @@ -232,10 +239,12 @@ fn show_fieldless_enum(
}
ast::VariantData::Unit(_) => cx.pat_path(span, variant_path),
};
cx.arm(span, pat, cx.expr_str(span, v.ident.name))
cx.arm(span, pat, cx.expr_usize(span, i))
})
.collect::<ThinVec<_>>();
let name = cx.expr_match(span, cx.expr_self(span), arms);
let match_expr = cx.expr_match(span, cx.expr_self(span), arms);
let name = cx.expr_index(span, array, match_expr);

let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]);
BlockOrExpr::new_expr(cx.expr_call_global(span, fn_path_write_str, thin_vec![fmt, name]))
}
19 changes: 19 additions & 0 deletions compiler/rustc_expand/src/build.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -250,6 +250,7 @@ impl<'a> ExtCtxt<'a> {
pub fn expr_ident(&self, span: Span, id: Ident) -> P<ast::Expr> {
self.expr_path(self.path_ident(span, id))
}

pub fn expr_self(&self, span: Span) -> P<ast::Expr> {
self.expr_ident(span, Ident::with_dummy_span(kw::SelfLower))
}
Expand All @@ -276,6 +277,10 @@ impl<'a> ExtCtxt<'a> {
self.expr(sp, ast::ExprKind::AddrOf(ast::BorrowKind::Ref, ast::Mutability::Not, e))
}

pub fn expr_index(&self, span: Span, val: P<ast::Expr>, index: P<ast::Expr>) -> P<ast::Expr> {
self.expr(span, ast::ExprKind::Index(val, index))
}

pub fn expr_paren(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprKind::Paren(e))
}
Expand All @@ -288,6 +293,7 @@ impl<'a> ExtCtxt<'a> {
) -> P<ast::Expr> {
self.expr(span, ast::ExprKind::Call(expr, args))
}

pub fn expr_call_ident(
&self,
span: Span,
Expand All @@ -296,6 +302,7 @@ impl<'a> ExtCtxt<'a> {
) -> P<ast::Expr> {
self.expr(span, ast::ExprKind::Call(self.expr_ident(span, id), args))
}

pub fn expr_call_global(
&self,
sp: Span,
Expand All @@ -305,9 +312,19 @@ impl<'a> ExtCtxt<'a> {
let pathexpr = self.expr_path(self.path_global(sp, fn_path));
self.expr_call(sp, pathexpr, args)
}

pub fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr> {
self.expr(b.span, ast::ExprKind::Block(b, None))
}

pub fn expr_const(&self, span: Span, kind: ast::ExprKind) -> P<ast::Expr> {
self.expr(span, ast::ExprKind::ConstBlock(self.anon_const(span, kind)))
}

pub fn expr_const_block(&self, span: Span, b: P<ast::Block>) -> P<ast::Expr> {
self.expr_const(span, ast::ExprKind::Block(b, None))
}

pub fn field_imm(&self, span: Span, ident: Ident, e: P<ast::Expr>) -> ast::ExprField {
ast::ExprField {
ident: ident.with_span_pos(span),
Expand All @@ -319,6 +336,7 @@ impl<'a> ExtCtxt<'a> {
is_placeholder: false,
}
}

pub fn expr_struct(
&self,
span: Span,
Expand All @@ -335,6 +353,7 @@ impl<'a> ExtCtxt<'a> {
})),
)
}

pub fn expr_struct_ident(
&self,
span: Span,
Expand Down
12 changes: 7 additions & 5 deletions tests/ui/deriving/deriving-all-codegen.stdout
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -997,11 +997,13 @@ impl ::core::marker::Copy for Fieldless { }
impl ::core::fmt::Debug for Fieldless {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
Fieldless::A => "A",
Fieldless::B => "B",
Fieldless::C => "C",
})
const {
["A", "B", "C"]
}[match self {
Fieldless::A => 0usize,
Fieldless::B => 1usize,
Fieldless::C => 2usize,
}])
}
}
#[automatically_derived]
Expand Down