internal: init: add tuple struct field and constructor syntax

Expand `init!` and `pin_init!` to initialize tuple structs using both
indexed brace syntax and tuple-constructor syntax.

Add tuple-specific runtime and UI coverage for the basic initializer
forms, duplicate/missing fields, invalid indices, and syntax errors.

Signed-off-by: Mohamad Alsadhan <mo@sdhn.cc>

Author: mqqz

CHANGELOG.md

@@ -8,8 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
-
-- Support tuple structs in `#[pin_data]`, including tuple struct projections.
+- Support tuple structs in `#[pin_data]`, including tuple struct projections, and tuple struct
+  initialization in `init!` and `pin_init!`.
 - `[pin_]init_scope` functions to run arbitrary code inside of an initializer.
 - `&'static mut MaybeUninit<T>` now implements `InPlaceWrite`. This enables users to use external
   allocation mechanisms such as `static_cell`.

internal/src/init.rs

@@ -3,12 +3,13 @@
 use proc_macro2::{Span, TokenStream};
 use quote::{format_ident, quote};
 use syn::{
-    braced,
+    braced, parenthesized,
     parse::{End, Parse},
     parse_quote,
     punctuated::Punctuated,
     spanned::Spanned,
-    token, Attribute, Block, Expr, ExprCall, ExprPath, Ident, Path, Token, Type,
+    token, Attribute, Block, Expr, ExprCall, ExprPath, Ident, Index, LitInt, Member, Path, Token,
+    Type,
 };
 
 use crate::diagnostics::{DiagCtxt, ErrorGuaranteed};
@@ -17,7 +18,7 @@ pub(crate) struct Initializer {
     attrs: Vec<InitializerAttribute>,
     this: Option<This>,
     path: Path,
-    brace_token: token::Brace,
+    close_span: Span,
     fields: Punctuated<InitializerField, Token![,]>,
     rest: Option<(Token![..], Expr)>,
     error: Option<(Token![?], Type)>,
@@ -34,13 +35,18 @@ struct InitializerField {
     kind: InitializerKind,
 }
 
+struct TupleInitializerField {
+    attrs: Vec<Attribute>,
+    value: Expr,
+}
+
 enum InitializerKind {
     Value {
-        ident: Ident,
+        member: Member,
         value: Option<(Token![:], Expr)>,
     },
     Init {
-        ident: Ident,
+        member: Member,
         _left_arrow_token: Token![<-],
         value: Expr,
     },
@@ -52,14 +58,28 @@ enum InitializerKind {
 }
 
 impl InitializerKind {
-    fn ident(&self) -> Option<&Ident> {
+    fn member(&self) -> Option<&Member> {
         match self {
-            Self::Value { ident, .. } | Self::Init { ident, .. } => Some(ident),
+            Self::Value { member, .. } | Self::Init { member, .. } => Some(member),
             Self::Code { .. } => None,
         }
     }
 }
 
+fn member_ident(member: &Member) -> Ident {
+    match member {
+        Member::Named(ident) => ident.clone(),
+        Member::Unnamed(Index { index, .. }) => format_ident!("_{index}"),
+    }
+}
+
+fn member_binding(member: &Member) -> Option<Ident> {
+    match member {
+        Member::Named(ident) => Some(ident.clone()),
+        Member::Unnamed(_) => None,
+    }
+}
+
 enum InitializerAttribute {
     DefaultError(DefaultErrorAttribute),
 }
@@ -73,7 +93,7 @@ pub(crate) fn expand(
         attrs,
         this,
         path,
-        brace_token,
+        close_span,
         fields,
         rest,
         error,
@@ -96,7 +116,7 @@ pub(crate) fn expand(
             } else if let Some(default_error) = default_error {
                 syn::parse_str(default_error).unwrap()
             } else {
-                dcx.error(brace_token.span.close(), "expected `? <type>` after `}`");
+                dcx.error(close_span, "expected `? <type>` after initializer");
                 parse_quote!(::core::convert::Infallible)
             }
         },
@@ -229,9 +249,9 @@ fn init_fields(
             cfgs
         };
 
-        let ident = match kind {
-            InitializerKind::Value { ident, .. } => ident,
-            InitializerKind::Init { ident, .. } => ident,
+        let member = match kind {
+            InitializerKind::Value { member, .. } => member,
+            InitializerKind::Init { member, .. } => member,
             InitializerKind::Code { block, .. } => {
                 res.extend(quote! {
                     #(#attrs)*
@@ -241,27 +261,38 @@ fn init_fields(
                 continue;
             }
         };
+        let ident = member_ident(member);
 
         let slot = if pinned {
-            quote! {
-                // SAFETY:
-                // - `slot` is valid and properly aligned.
-                // - `make_field_check` checks that `&raw mut (*slot).#ident` is properly aligned.
-                // - `make_field_check` prevents `#ident` from being used twice, therefore
-                //   `(*slot).#ident` is exclusively accessed and has not been initialized.
-                (unsafe { #data.#ident(#slot) })
+            match member {
+                Member::Named(_) => quote! {
+                    // SAFETY:
+                    // - `slot` is valid and properly aligned.
+                    // - `make_field_check` checks that the field is properly aligned.
+                    // - `make_field_check` prevents the field from being used twice, therefore
+                    //   it is exclusively accessed and has not been initialized.
+                    (unsafe { #data.#ident(#slot) })
+                },
+                Member::Unnamed(_) => quote! {
+                    // SAFETY:
+                    // - `slot` is valid and properly aligned.
+                    // - `make_field_check` checks that the field is properly aligned.
+                    // - `make_field_check` prevents the field from being used twice, therefore
+                    //   it is exclusively accessed and has not been initialized.
+                    (unsafe { #data.#member.slot(&raw mut (*#slot).#member) })
+                },
             }
         } else {
             quote! {
                 // For `init!()` macro, everything is unpinned.
                 // SAFETY:
-                // - `&raw mut (*slot).#ident` is valid.
-                // - `make_field_check` checks that `&raw mut (*slot).#ident` is properly aligned.
-                // - `make_field_check` prevents `#ident` from being used twice, therefore
-                //   `(*slot).#ident` is exclusively accessed and has not been initialized.
+                // - The field pointer is valid.
+                // - `make_field_check` checks that the field is properly aligned.
+                // - `make_field_check` prevents the field from being used twice, therefore
+                //   it is exclusively accessed and has not been initialized.
                 (unsafe {
                     ::pin_init::__internal::Slot::<::pin_init::__internal::Unpinned, _>::new(
-                        &raw mut (*#slot).#ident
+                        &raw mut (*#slot).#member
                     )
                 })
             }
@@ -271,7 +302,7 @@ fn init_fields(
         let guard = format_ident!("__{ident}_guard", span = Span::mixed_site());
 
         let init = match kind {
-            InitializerKind::Value { ident, value } => {
+            InitializerKind::Value { value, .. } => {
                 let value = value
                     .as_ref()
                     .map(|(_, value)| quote!(#value))
@@ -291,13 +322,18 @@ fn init_fields(
             }
             InitializerKind::Code { .. } => unreachable!(),
         };
+        let binding = member_binding(member).map(|ident| {
+            quote! {
+                #(#cfgs)*
+                #[allow(unused_variables)]
+                let #ident = #guard.let_binding();
+            }
+        });
 
         res.extend(quote! {
             #init
 
-            #(#cfgs)*
-            #[allow(unused_variables)]
-            let #ident = #guard.let_binding();
+            #binding
         });
 
         guards.push(guard);
@@ -322,9 +358,9 @@ fn make_field_check(
 ) -> TokenStream {
     let field_attrs: Vec<_> = fields
         .iter()
-        .filter_map(|f| f.kind.ident().map(|_| &f.attrs))
+        .filter_map(|f| f.kind.member().map(|_| &f.attrs))
         .collect();
-    let field_name: Vec<_> = fields.iter().filter_map(|f| f.kind.ident()).collect();
+    let field_name: Vec<_> = fields.iter().filter_map(|f| f.kind.member()).collect();
     let zeroing_trailer = match init_kind {
         InitKind::Normal => None,
         InitKind::Zeroing => Some(quote! {
@@ -360,36 +396,73 @@ fn make_field_check(
     }
 }
 
-impl Parse for Initializer {
-    fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
-        let attrs = input.call(Attribute::parse_outer)?;
-        let this = input.peek(Token![&]).then(|| input.parse()).transpose()?;
-        let path = input.parse()?;
-        let content;
-        let brace_token = braced!(content in input);
-        let mut fields = Punctuated::new();
-        loop {
+type InitFields = Punctuated<InitializerField, Token![,]>;
+type InitRest = Option<(Token![..], Expr)>;
+
+fn parse_brace_initializer(
+    input: syn::parse::ParseStream<'_>,
+) -> syn::Result<(Span, InitFields, InitRest)> {
+    let content;
+    let brace_token = braced!(content in input);
+    let mut fields = Punctuated::new();
+    loop {
+        let lh = content.lookahead1();
+        if lh.peek(End) || lh.peek(Token![..]) {
+            break;
+        } else if lh.peek(Ident) || lh.peek(LitInt) || lh.peek(Token![_]) || lh.peek(Token![#]) {
+            fields.push_value(content.parse()?);
             let lh = content.lookahead1();
-            if lh.peek(End) || lh.peek(Token![..]) {
+            if lh.peek(End) {
                 break;
-            } else if lh.peek(Ident) || lh.peek(Token![_]) || lh.peek(Token![#]) {
-                fields.push_value(content.parse()?);
-                let lh = content.lookahead1();
-                if lh.peek(End) {
-                    break;
-                } else if lh.peek(Token![,]) {
-                    fields.push_punct(content.parse()?);
-                } else {
-                    return Err(lh.error());
-                }
+            } else if lh.peek(Token![,]) {
+                fields.push_punct(content.parse()?);
             } else {
                 return Err(lh.error());
             }
+        } else {
+            return Err(lh.error());
         }
-        let rest = content
-            .peek(Token![..])
-            .then(|| Ok::<_, syn::Error>((content.parse()?, content.parse()?)))
-            .transpose()?;
+    }
+    let rest = content
+        .peek(Token![..])
+        .then(|| Ok::<_, syn::Error>((content.parse()?, content.parse()?)))
+        .transpose()?;
+    Ok((brace_token.span.close(), fields, rest))
+}
+
+fn parse_paren_initializer(input: syn::parse::ParseStream<'_>) -> syn::Result<(Span, InitFields)> {
+    let content;
+    let paren_token = parenthesized!(content in input);
+    let tuple_fields = content.parse_terminated(TupleInitializerField::parse, Token![,])?;
+    let mut fields = Punctuated::new();
+    for (index, tuple_field) in tuple_fields.into_iter().enumerate() {
+        fields.push(InitializerField {
+            attrs: tuple_field.attrs,
+            kind: InitializerKind::Value {
+                member: Member::Unnamed(Index {
+                    index: index as u32,
+                    span: tuple_field.value.span(),
+                }),
+                value: Some((Token![:](tuple_field.value.span()), tuple_field.value)),
+            },
+        });
+    }
+    Ok((paren_token.span.close(), fields))
+}
+
+impl Parse for Initializer {
+    fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        let this = input.peek(Token![&]).then(|| input.parse()).transpose()?;
+        let path = input.parse()?;
+        let (close_span, fields, rest) = if input.peek(token::Brace) {
+            parse_brace_initializer(input)?
+        } else if input.peek(token::Paren) {
+            let (close_span, fields) = parse_paren_initializer(input)?;
+            (close_span, fields, None)
+        } else {
+            return Err(input.error("expected curly braces or parentheses"));
+        };
         let error = input
             .peek(Token![?])
             .then(|| Ok::<_, syn::Error>((input.parse()?, input.parse()?)))
@@ -409,7 +482,7 @@ impl Parse for Initializer {
             attrs,
             this,
             path,
-            brace_token,
+            close_span,
             fields,
             rest,
             error,
@@ -452,22 +525,43 @@ impl Parse for InitializerKind {
                 _colon_token: input.parse()?,
                 block: input.parse()?,
             })
-        } else if lh.peek(Ident) {
-            let ident = input.parse()?;
+        } else if lh.peek(Ident) || lh.peek(LitInt) {
+            let member = if lh.peek(Ident) {
+                Member::Named(input.parse()?)
+            } else {
+                let lit: LitInt = input.parse()?;
+                let index: u32 = lit.base10_parse().map_err(|_| {
+                    syn::Error::new(
+                        lit.span(),
+                        "tuple field index must be a non-negative integer",
+                    )
+                })?;
+                Member::Unnamed(Index {
+                    index,
+                    span: lit.span(),
+                })
+            };
             let lh = input.lookahead1();
             if lh.peek(Token![<-]) {
                 Ok(Self::Init {
-                    ident,
+                    member,
                     _left_arrow_token: input.parse()?,
                     value: input.parse()?,
                 })
             } else if lh.peek(Token![:]) {
                 Ok(Self::Value {
-                    ident,
+                    member,
                     value: Some((input.parse()?, input.parse()?)),
                 })
             } else if lh.peek(Token![,]) || lh.peek(End) {
-                Ok(Self::Value { ident, value: None })
+                if matches!(member, Member::Unnamed(_)) {
+                    Err(lh.error())
+                } else {
+                    Ok(Self::Value {
+                        member,
+                        value: None,
+                    })
+                }
             } else {
                 Err(lh.error())
             }
@@ -476,3 +570,18 @@ impl Parse for InitializerKind {
         }
     }
 }
+
+impl Parse for TupleInitializerField {
+    fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        if input.peek(Token![<-]) {
+            return Err(input.error(
+                "`<-` is not supported in tuple constructor syntax; use braces with indices, e.g. `Type { 0 <- init, 1: value }`",
+            ));
+        }
+        Ok(Self {
+            attrs,
+            value: input.parse()?,
+        })
+    }
+}