Disallow deriving (other than Copy/Clone) on types with unnamed fields

compiler/rustc_builtin_macros/messages.ftl

@@ -245,3 +245,9 @@ builtin_macros_unexpected_lit = expected path to a trait, found literal
  .other = for example, write `#[derive(Debug)]` for `Debug`
 
 builtin_macros_unnameable_test_items = cannot test inner items
+
+builtin_macros_unnamed_field_derive = only `Copy` and `Clone` may be derived on structs with unnamed fields
+ .note = unnamed field
+
+builtin_macros_unnamed_field_derive_clone =
+ deriving `Clone` on a type with unnamed fields requires also deriving `Copy`

compiler/rustc_builtin_macros/src/deriving/clone.rs

@@ -1,6 +1,7 @@
 use crate::deriving::generic::ty::*;
 use crate::deriving::generic::*;
 use crate::deriving::path_std;
+use crate::errors;
 use rustc_ast::{self as ast, Generics, ItemKind, MetaItem, VariantData};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_expand::base::{Annotatable, ExtCtxt};
@@ -32,42 +33,52 @@ pub fn expand_deriving_clone(
  let bounds;
  let substructure;
  let is_simple;
- match item {
- Annotatable::Item(annitem) => match &annitem.kind {
- ItemKind::Struct(_, Generics { params, .. })
- | ItemKind::Enum(_, Generics { params, .. }) => {
- let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
- let has_derive_copy = cx.resolver.has_derive_copy(container_id);
- if has_derive_copy
- && !params
- .iter()
- .any(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
- {
- bounds = vec![];
- is_simple = true;
- substructure = combine_substructure(Box::new(|c, s, sub| {
- cs_clone_simple("Clone", c, s, sub, false)
- }));
- } else {
- bounds = vec![];
- is_simple = false;
- substructure =
- combine_substructure(Box::new(|c, s, sub| cs_clone("Clone", c, s, sub)));
- }
- }
- ItemKind::Union(..) => {
- bounds = vec![Path(path_std!(marker::Copy))];
+ let Annotatable::Item(annitem) = item else {
+ cx.dcx().span_bug(span, "`#[derive(Clone)]` on trait item or impl item")
+ };
+ let has_unnamed = if let ItemKind::Struct(VariantData::Struct { fields, .. }, _) = &annitem.kind
+ {
+ fields.iter().any(|f| f.ident.is_some_and(|i| i.name == kw::Underscore))
+ } else {
+ false
+ };
+ match &annitem.kind {
+ ItemKind::Struct(_, Generics { params, .. })
+ | ItemKind::Enum(_, Generics { params, .. }) => {
+ let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
+ let has_derive_copy = cx.resolver.has_derive_copy(container_id);
+ if has_derive_copy
+ && !params
+ .iter()
+ .any(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
+ {
+ bounds = vec![];
  is_simple = true;
  substructure = combine_substructure(Box::new(|c, s, sub| {
- cs_clone_simple("Clone", c, s, sub, true)
+ cs_clone_simple("Clone", c, s, sub, false)
  }));
+ } else {
+ bounds = vec![];
+ is_simple = false;
+ substructure =
+ combine_substructure(Box::new(|c, s, sub| cs_clone("Clone", c, s, sub)));
  }
- _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
- },
-
- _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on trait item or impl item"),
+ }
+ ItemKind::Union(..) => {
+ bounds = vec![Path(path_std!(marker::Copy))];
+ is_simple = true;
+ substructure = combine_substructure(Box::new(|c, s, sub| {
+ cs_clone_simple("Clone", c, s, sub, true)
+ }));
+ }
+ _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
  }
 
+ if !is_simple && has_unnamed {
+ cx.dcx().emit_err(errors::UnnamedFieldDeriveClone { span });
+ return;
+ };
+
  let trait_def = TraitDef {
  span,
  path: path_std!(clone::Clone),

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -475,6 +475,26 @@ impl<'a> TraitDef<'a> {
  false
  });
 
+ if let ast::ItemKind::Struct(struct_def, _) | ast::ItemKind::Union(struct_def, _) =
+ &item.kind
+ && let Some(&trait_name) = self.path.components().last()
+ && !(trait_name == sym::Copy || trait_name == sym::Clone)
+ {
+ let unnamed = struct_def
+ .fields()
+ .iter()
+ .filter(|f| f.ident.is_some_and(|i| i.name == kw::Underscore))
+ .map(|f| f.span)
+ .collect::<Vec<_>>();
+ if !unnamed.is_empty() {
+ cx.dcx().emit_err(errors::UnnamedFieldDerive {
+ span: self.span,
+ fields: unnamed,
+ });
+ return;
+ }
+ };
+
  let newitem = match &item.kind {
  ast::ItemKind::Struct(struct_def, generics) => self.expand_struct_def(
  cx,

compiler/rustc_builtin_macros/src/deriving/generic/ty.rs

@@ -48,6 +48,7 @@ impl Path {
  ) -> P<ast::Ty> {
  cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
  }
+
  pub fn to_path(
  &self,
  cx: &ExtCtxt<'_>,
@@ -69,6 +70,10 @@ impl Path {
  }
  }
  }
+
+ pub fn components(&self) -> &[Symbol] {
+ &self.path
+ }
 }
 
 /// A type. Supports pointers, Self, and literals.

compiler/rustc_builtin_macros/src/errors.rs

@@ -842,6 +842,22 @@ pub(crate) struct TestRunnerNargs {
  pub(crate) span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(builtin_macros_unnamed_field_derive)]
+pub(crate) struct UnnamedFieldDerive {
+ #[primary_span]
+ pub(crate) span: Span,
+ #[note]
+ pub(crate) fields: Vec<Span>,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_unnamed_field_derive_clone)]
+pub(crate) struct UnnamedFieldDeriveClone {
+ #[primary_span]
+ pub(crate) span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(builtin_macros_expected_register_class_or_explicit_register)]
 pub(crate) struct ExpectedRegisterClassOrExplicitRegister {

compiler/rustc_expand/src/build.rs

@@ -324,6 +324,9 @@ impl<'a> ExtCtxt<'a> {
  is_placeholder: false,
  }
  }
+ pub fn expr_err(&self, span: Span) -> P<ast::Expr> {
+ self.expr(span, ast::ExprKind::Err)
+ }
  pub fn expr_struct(
  &self,
  span: Span,

tests/ui/union/unnamed-fields/derive.rs

@@ -0,0 +1,29 @@
+#![allow(incomplete_features)]
+#![feature(unnamed_fields)]
+
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+struct Foo {
+ a: u8,
+}
+
+#[repr(C)]
+#[derive(Debug)] //~ ERROR only `Copy` and `Clone` may be derived on structs with unnamed fields
+struct TestUnsupported {
+ _: Foo,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct Test {
+ _: Foo,
+}
+
+#[repr(C)]
+#[derive(Clone)] //~ ERROR deriving `Clone` on a type with unnamed fields requires also deriving `Copy`
+struct TestClone {
+ _: Foo,
+}
+
+
+fn main() {}

tests/ui/union/unnamed-fields/derive.stderr

@@ -0,0 +1,23 @@
+error: only `Copy` and `Clone` may be derived on structs with unnamed fields
+ --> $DIR/derive.rs:11:10
+ |
+LL | #[derive(Debug)]
+ | ^^^^^
+ |
+note: unnamed field
+ --> $DIR/derive.rs:13:5
+ |
+LL | _: Foo,
+ | ^^^^^^
+ = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: deriving `Clone` on a type with unnamed fields requires also deriving `Copy`
+ --> $DIR/derive.rs:23:10
+ |
+LL | #[derive(Clone)]
+ | ^^^^^
+ |
+ = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
+