Generate From impl even if there is not exactly a single field

Author: Kobzol

compiler/rustc_builtin_macros/src/deriving/from.rs

@@ -1,13 +1,13 @@
 use rustc_ast as ast;
 use rustc_ast::{ItemKind, VariantData};
-use rustc_expand::base::{Annotatable, ExtCtxt};
-use rustc_span::{kw, sym, Ident, Span};
+use rustc_expand::base::{Annotatable, DummyResult, ExtCtxt};
+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::{
-    combine_substructure, BlockOrExpr, FieldlessVariantsStrategy, MethodDef, SubstructureFields,
-    TraitDef,
+    BlockOrExpr, FieldlessVariantsStrategy, MethodDef, SubstructureFields, TraitDef,
+    combine_substructure,
 };
 use crate::deriving::pathvec_std;
 use crate::errors;
@@ -22,6 +22,7 @@ pub(crate) fn expand_deriving_from(
     push: &mut dyn FnMut(Annotatable),
     is_const: bool,
 ) {
+    // #[derive(From)] is currently usable only on structs with exactly one field.
     let field = match &item {
         Annotatable::Item(item) => match &item.kind {
             ItemKind::Struct(_, _, data) => match data.fields() {
@@ -33,18 +34,14 @@ pub(crate) fn expand_deriving_from(
         _ => None,
     };
 
-    // 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) = field else {
-        cx.dcx().emit_err(errors::DeriveFromWrongTarget { span });
-        return;
+    let from_type = match &field {
+        Some(field) => Ty::AstTy(field.ty.clone()),
+        // We don't have a type to put into From<...> if we don't have a single field, so just put
+        // unit there.
+        None => Ty::Unit,
     };
-
-    let path = Path::new_(
-        pathvec_std!(convert::From),
-        vec![Box::new(Ty::AstTy(field.ty.clone()))],
-        PathKind::Std,
-    );
+    let path =
+        Path::new_(pathvec_std!(convert::From), vec![Box::new(from_type.clone())], PathKind::Std);
 
     // Generate code like this:
     //
@@ -67,11 +64,16 @@ pub(crate) fn expand_deriving_from(
             name: sym::from,
             generics: Bounds { bounds: vec![] },
             explicit_self: false,
-            nonself_args: vec![(Ty::AstTy(field.ty), sym::value)],
+            nonself_args: vec![(from_type, 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 Some(field) = &field else {
+                    let error = cx.dcx().emit_err(errors::DeriveFromWrongTarget { span });
+                    return BlockOrExpr::new_expr(DummyResult::raw_expr(span, Some(error)));
+                };
+
                 let self_kw = Ident::new(kw::SelfUpper, span);
                 let expr: Box<ast::Expr> = match substructure.fields {
                     SubstructureFields::StaticStruct(variant, _) => match variant {