Implement #[derive(From)]

Kobzol · Kobzol · commit 60eac40d1282 · 2025-08-11T20:41:43.000+02:00
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
@@ -222,6 +222,8 @@ builtin_macros_format_unused_args = multiple unused formatting arguments
 
 builtin_macros_format_use_positional = consider using a positional formatting argument instead
 
+builtin_macros_from_wrong_target = `#[derive(From)]` can only be used on structs with a single field
+
 builtin_macros_multiple_default_attrs = multiple `#[default]` attributes
     .note = only one `#[default]` attribute is needed
     .label = `#[default]` used here
diff --git a/compiler/rustc_builtin_macros/src/deriving/from.rs b/compiler/rustc_builtin_macros/src/deriving/from.rs
@@ -1,7 +1,19 @@
 use rustc_ast as ast;
+use rustc_ast::{FieldDef, Item, ItemKind, VariantData};
 use rustc_expand::base::{Annotatable, ExtCtxt};
-use rustc_span::{Span, sym};
+use rustc_span::{Ident, Span, kw, sym};
+use thin_vec::thin_vec;
 
+use crate::deriving::generic::ty::{Bounds, Path, PathKind, Ty};
+use crate::deriving::generic::{
+    BlockOrExpr, FieldlessVariantsStrategy, MethodDef, SubstructureFields, TraitDef,
+    combine_substructure,
+};
+use crate::deriving::pathvec_std;
+use crate::errors;
+
+/// Generate an implementation of the `From` trait, provided that `item`
+/// is a struct or a tuple struct with exactly one field.
 pub(crate) fn expand_deriving_from(
     cx: &ExtCtxt<'_>,
     span: Span,
@@ -10,4 +22,99 @@ pub(crate) fn expand_deriving_from(
     push: &mut dyn FnMut(Annotatable),
     is_const: bool,
 ) {
+    let mut visitor = ExtractNonSingleFieldStruct { cx, field: None };
+    item.visit_with(&mut visitor);
+
+    // Make sure that the derive is only invoked on single-field [tuple] structs.
+    // From this point below, we know that there is exactly one field.
+    let Some(field) = visitor.field else { return };
+
+    let path = Path::new_(
+        pathvec_std!(convert::From),
+        vec![Box::new(Ty::AstTy(field.ty.clone()))],
+        PathKind::Std,
+    );
+
+    // Generate code like this:
+    //
+    // struct S(u32);
+    // #[automatically_derived]
+    // impl ::core::convert::From<u32> for S {
+    //     #[inline]
+    //     fn from(value: u32) -> S {
+    //         Self(value)
+    //     }
+    // }
+    let from_trait_def = TraitDef {
+        span,
+        path,
+        skip_path_as_bound: true,
+        needs_copy_as_bound_if_packed: false,
+        additional_bounds: Vec::new(),
+        supports_unions: false,
+        methods: vec![MethodDef {
+            name: sym::from,
+            generics: Bounds { bounds: vec![] },
+            explicit_self: false,
+            nonself_args: vec![(Ty::AstTy(field.ty), sym::value)],
+            ret_ty: Ty::Self_,
+            attributes: thin_vec![cx.attr_word(sym::inline, span)],
+            fieldless_variants_strategy: FieldlessVariantsStrategy::Default,
+            combine_substructure: combine_substructure(Box::new(|cx, span, substructure| {
+                let self_kw = Ident::new(kw::SelfUpper, span);
+                let expr: Box<ast::Expr> = match substructure.fields {
+                    SubstructureFields::StaticStruct(variant, _) => match variant {
+                        // Self {
+                        //     field: value
+                        // }
+                        VariantData::Struct { .. } => cx.expr_struct_ident(
+                            span,
+                            self_kw,
+                            thin_vec![cx.field_imm(
+                                span,
+                                field.ident.unwrap(),
+                                cx.expr_ident(span, Ident::new(sym::value, span))
+                            )],
+                        ),
+                        // Self(value)
+                        VariantData::Tuple(_, _) => cx.expr_call_ident(
+                            span,
+                            self_kw,
+                            thin_vec![cx.expr_ident(span, Ident::new(sym::value, span))],
+                        ),
+                        variant => {
+                            cx.dcx().bug(format!("Invalid derive(From) ADT variant: {variant:?}"));
+                        }
+                    },
+                    _ => cx.dcx().bug("Invalid derive(From) ADT input"),
+                };
+                BlockOrExpr::new_expr(expr)
+            })),
+        }],
+        associated_types: Vec::new(),
+        is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
+    };
+
+    from_trait_def.expand(cx, mitem, item, push);
+}
+
+struct ExtractNonSingleFieldStruct<'a, 'b> {
+    cx: &'a ExtCtxt<'b>,
+    field: Option<FieldDef>,
+}
+
+impl<'a, 'b> rustc_ast::visit::Visitor<'a> for ExtractNonSingleFieldStruct<'a, 'b> {
+    fn visit_item(&mut self, item: &'a Item) -> Self::Result {
+        match &item.kind {
+            ItemKind::Struct(_, _, data) => match data.fields() {
+                [field] => self.field = Some(field.clone()),
+                _ => {}
+            },
+            _ => {}
+        };
+        if self.field.is_none() {
+            self.cx.dcx().emit_err(errors::DeriveFromWrongTarget { span: item.span });
+        }
+    }
 }
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
@@ -2,7 +2,7 @@
 //! when specifying impls to be derived.
 
 pub(crate) use Ty::*;
-use rustc_ast::{self as ast, Expr, GenericArg, GenericParamKind, Generics, SelfKind};
+use rustc_ast::{self as ast, Expr, GenericArg, GenericParamKind, Generics, SelfKind, TyKind};
 use rustc_expand::base::ExtCtxt;
 use rustc_span::source_map::respan;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw};
@@ -65,7 +65,7 @@ impl Path {
     }
 }
 
-/// A type. Supports pointers, Self, and literals.
+/// A type. Supports pointers, Self, literals, unit or an arbitrary AST path.
 #[derive(Clone)]
 pub(crate) enum Ty {
     Self_,
@@ -76,6 +76,8 @@ pub(crate) enum Ty {
     Path(Path),
     /// For () return types.
     Unit,
+    /// An arbitrary type.
+    AstTy(Box<ast::Ty>),
 }
 
 pub(crate) fn self_ref() -> Ty {
@@ -101,6 +103,7 @@ impl Ty {
                 let ty = ast::TyKind::Tup(ThinVec::new());
                 cx.ty(span, ty)
             }
+            AstTy(ty) => ty.clone(),
         }
     }
 
@@ -132,6 +135,10 @@ impl Ty {
                 cx.path_all(span, false, vec![self_ty], params)
             }
             Path(p) => p.to_path(cx, span, self_ty, generics),
+            AstTy(ty) => match &ty.kind {
+                TyKind::Path(_, path) => path.clone(),
+                _ => cx.dcx().span_bug(span, "non-path in a path in generic `derive`"),
+            },
             Ref(..) => cx.dcx().span_bug(span, "ref in a path in generic `derive`"),
             Unit => cx.dcx().span_bug(span, "unit in a path in generic `derive`"),
         }
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
@@ -446,6 +446,13 @@ pub(crate) struct DefaultHasArg {
     pub(crate) span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(builtin_macros_from_wrong_target)]
+pub(crate) struct DeriveFromWrongTarget {
+    #[primary_span]
+    pub(crate) span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(builtin_macros_derive_macro_call)]
 pub(crate) struct DeriveMacroCall {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -392,6 +392,7 @@ symbols! {
         __D,
         __H,
         __S,
+        __T,
         __awaitee,
         __try_var,
         _t,
@@ -743,6 +744,7 @@ symbols! {
         contracts_ensures,
         contracts_internals,
         contracts_requires,
+        convert,
         convert_identity,
         copy,
         copy_closures,
@@ -2325,6 +2327,7 @@ symbols! {
         va_start,
         val,
         validity,
+        value,
         values,
         var,
         variant_count,
diff --git a/tests/ui/deriving/deriving-from-wrong-target.rs b/tests/ui/deriving/deriving-from-wrong-target.rs
@@ -0,0 +1,52 @@
+//@ edition: 2021
+//@ check-fail
+
+#![feature(derive_from)]
+#![allow(dead_code)]
+
+#[derive(From)]
+struct S1;
+//~^ ERROR `#[derive(From)]` can only be used on structs with a single field
+
+#[derive(From)]
+struct S2 {}
+//~^ ERROR `#[derive(From)]` can only be used on structs with a single field
+
+#[derive(From)]
+struct S3(u32, bool);
+//~^ ERROR `#[derive(From)]` can only be used on structs with a single field
+
+#[derive(From)]
+//~v ERROR `#[derive(From)]` can only be used on structs with a single field
+struct S4 {
+    a: u32,
+    b: bool,
+}
+
+#[derive(From)]
+enum E1 {}
+//~^ ERROR `#[derive(From)]` can only be used on structs with a single field
+
+#[derive(From)]
+//~v ERROR `#[derive(From)]` can only be used on structs with a single field
+enum E2 {
+    V1,
+    V2,
+}
+
+#[derive(From)]
+//~v ERROR `#[derive(From)]` can only be used on structs with a single field
+enum E3 {
+    V1(u32),
+    V2(bool),
+}
+
+#[derive(From)]
+//~^ ERROR the size for values of type `T` cannot be known at compilation time [E0277]
+//~| ERROR the size for values of type `T` cannot be known at compilation time [E0277]
+struct SUnsizedField<T: ?Sized> {
+    last: T,
+    //~^ ERROR the size for values of type `T` cannot be known at compilation time [E0277]
+}
+
+fn main() {}
diff --git a/tests/ui/deriving/deriving-from-wrong-target.stderr b/tests/ui/deriving/deriving-from-wrong-target.stderr
@@ -0,0 +1,111 @@
+error: `#[derive(From)]` can only be used on structs with a single field
+  --> $DIR/deriving-from-wrong-target.rs:8:1
+   |
+LL | struct S1;
+   | ^^^^^^^^^^
+
+error: `#[derive(From)]` can only be used on structs with a single field
+  --> $DIR/deriving-from-wrong-target.rs:12:1
+   |
+LL | struct S2 {}
+   | ^^^^^^^^^^^^
+
+error: `#[derive(From)]` can only be used on structs with a single field
+  --> $DIR/deriving-from-wrong-target.rs:16:1
+   |
+LL | struct S3(u32, bool);
+   | ^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[derive(From)]` can only be used on structs with a single field
+  --> $DIR/deriving-from-wrong-target.rs:21:1
+   |
+LL | / struct S4 {
+LL | |     a: u32,
+LL | |     b: bool,
+LL | | }
+   | |_^
+
+error: `#[derive(From)]` can only be used on structs with a single field
+  --> $DIR/deriving-from-wrong-target.rs:27:1
+   |
+LL | enum E1 {}
+   | ^^^^^^^^^^
+
+error: `#[derive(From)]` can only be used on structs with a single field
+  --> $DIR/deriving-from-wrong-target.rs:32:1
+   |
+LL | / enum E2 {
+LL | |     V1,
+LL | |     V2,
+LL | | }
+   | |_^
+
+error: `#[derive(From)]` can only be used on structs with a single field
+  --> $DIR/deriving-from-wrong-target.rs:39:1
+   |
+LL | / enum E3 {
+LL | |     V1(u32),
+LL | |     V2(bool),
+LL | | }
+   | |_^
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/deriving-from-wrong-target.rs:44:10
+   |
+LL | #[derive(From)]
+   |          ^^^^ doesn't have a size known at compile-time
+...
+LL | struct SUnsizedField<T: ?Sized> {
+   |                      - this type parameter needs to be `Sized`
+   |
+note: required by an implicit `Sized` bound in `From`
+  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+LL - struct SUnsizedField<T: ?Sized> {
+LL + struct SUnsizedField<T> {
+   |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/deriving-from-wrong-target.rs:44:10
+   |
+LL | #[derive(From)]
+   |          ^^^^ doesn't have a size known at compile-time
+...
+LL | struct SUnsizedField<T: ?Sized> {
+   |                      - this type parameter needs to be `Sized`
+   |
+note: required because it appears within the type `SUnsizedField<T>`
+  --> $DIR/deriving-from-wrong-target.rs:47:8
+   |
+LL | struct SUnsizedField<T: ?Sized> {
+   |        ^^^^^^^^^^^^^
+   = note: the return type of a function must have a statically known size
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+LL - struct SUnsizedField<T: ?Sized> {
+LL + struct SUnsizedField<T> {
+   |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/deriving-from-wrong-target.rs:48:11
+   |
+LL | struct SUnsizedField<T: ?Sized> {
+   |                      - this type parameter needs to be `Sized`
+LL |     last: T,
+   |           ^ doesn't have a size known at compile-time
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+LL - struct SUnsizedField<T: ?Sized> {
+LL + struct SUnsizedField<T> {
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL |     last: &T,
+   |           +
+
+error: aborting due to 10 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/deriving/deriving-from.rs b/tests/ui/deriving/deriving-from.rs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`//! when specifying impls to be derived.`
`3`	`3`
`4`	`4`	`pub(crate) use Ty::*;`
`5`		`-use rustc_ast::{self as ast, Expr, GenericArg, GenericParamKind, Generics, SelfKind};`
	`5`	`+use rustc_ast::{self as ast, Expr, GenericArg, GenericParamKind, Generics, SelfKind, TyKind};`
`6`	`6`	`use rustc_expand::base::ExtCtxt;`
`7`	`7`	`use rustc_span::source_map::respan;`
`8`	`8`	`use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw};`
`@@ -65,7 +65,7 @@ impl Path {`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`-/// A type. Supports pointers, Self, and literals.`
	`68`	`+/// A type. Supports pointers, Self, literals, unit or an arbitrary AST path.`
`69`	`69`	`#[derive(Clone)]`
`70`	`70`	`pub(crate) enum Ty {`
`71`	`71`	`Self_,`
`@@ -76,6 +76,8 @@ pub(crate) enum Ty {`
`76`	`76`	`Path(Path),`
`77`	`77`	`/// For () return types.`
`78`	`78`	`Unit,`
	`79`	`+ /// An arbitrary type.`
	`80`	`+ AstTy(Box<ast::Ty>),`
`79`	`81`	`}`
`80`	`82`
`81`	`83`	`pub(crate) fn self_ref() -> Ty {`
`@@ -101,6 +103,7 @@ impl Ty {`
`101`	`103`	`let ty = ast::TyKind::Tup(ThinVec::new());`
`102`	`104`	`cx.ty(span, ty)`
`103`	`105`	`}`
	`106`	`+ AstTy(ty) => ty.clone(),`
`104`	`107`	`}`
`105`	`108`	`}`
`106`	`109`
`@@ -132,6 +135,10 @@ impl Ty {`
`132`	`135`	`cx.path_all(span, false, vec![self_ty], params)`
`133`	`136`	`}`
`134`	`137`	`Path(p) => p.to_path(cx, span, self_ty, generics),`
	`138`	`+ AstTy(ty) => match &ty.kind {`
	`139`	`+ TyKind::Path(_, path) => path.clone(),`
	`140`	+ _ => cx.dcx().span_bug(span, "non-path in a path in generic `derive`"),
	`141`	`+ },`
`135`	`142`	Ref(..) => cx.dcx().span_bug(span, "ref in a path in generic `derive`"),
`136`	`143`	Unit => cx.dcx().span_bug(span, "unit in a path in generic `derive`"),
`137`	`144`	`}`