internal: init: support cfg-stripped tuple fields and arguments

Handle tuple structs whose fields or constructor arguments are removed
by `#[cfg]`.

For tuple projections and tuple-constructor lowering, generate the
needed cfg-specific layouts instead of trying to evaluate user cfgs
inside the proc macro, and let rustc select the active branch.

Add regression tests covering cfg-stripped tuple fields, cfg-stripped
tuple constructor arguments, and feature-dependent field layouts.

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

Author: mqqz

internal/src/init.rs

@@ -80,6 +80,15 @@ fn member_binding(member: &Member) -> Option<Ident> {
     }
 }
 
+fn cfg_condition(attrs: &[Attribute]) -> Option<TokenStream> {
+    let cfgs: Vec<_> = attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("cfg"))
+        .filter_map(|attr| attr.parse_args::<syn::Meta>().ok())
+        .collect();
+    (!cfgs.is_empty()).then(|| quote!(all(#(#cfgs),*)))
+}
+
 enum InitializerAttribute {
     DefaultError(DefaultErrorAttribute),
 }
@@ -434,18 +443,69 @@ fn parse_paren_initializer(input: syn::parse::ParseStream<'_>) -> syn::Result<(S
     let content;
     let paren_token = parenthesized!(content in input);
     let tuple_fields = content.parse_terminated(TupleInitializerField::parse, Token![,])?;
+    let tuple_fields: Vec<_> = tuple_fields.into_iter().collect();
+    let cfg_conditions: Vec<_> = tuple_fields
+        .iter()
+        .map(|field| cfg_condition(&field.attrs))
+        .collect();
+    let conditional_fields: Vec<_> = cfg_conditions
+        .iter()
+        .enumerate()
+        .filter_map(|(index, cfg)| cfg.as_ref().map(|cfg| (index, cfg)))
+        .collect();
+
     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)),
-            },
-        });
+
+    // Tuple constructor arguments are reindexed by rustc after cfg stripping. Since the proc macro
+    // cannot evaluate user cfgs, generate one initializer sequence for every cfg combination.
+    for combination in 0..(1usize << conditional_fields.len()) {
+        let cfgs: Vec<_> = conditional_fields
+            .iter()
+            .enumerate()
+            .map(|(bit, (_, cfg))| {
+                if combination & (1 << bit) == 0 {
+                    quote!(not(#cfg))
+                } else {
+                    quote!(#cfg)
+                }
+            })
+            .collect();
+        let combination_attr: Option<Attribute> =
+            (!cfgs.is_empty()).then(|| parse_quote!(#[cfg(all(#(#cfgs),*))]));
+        let mut active_index = 0u32;
+
+        for (index, tuple_field) in tuple_fields.iter().enumerate() {
+            let included = match cfg_conditions[index] {
+                None => true,
+                Some(_) => {
+                    let bit = conditional_fields
+                        .iter()
+                        .position(|(field_index, _)| *field_index == index)
+                        .expect("cfg-bearing field must be present");
+                    combination & (1 << bit) != 0
+                }
+            };
+            if !included {
+                continue;
+            }
+
+            let mut attrs = tuple_field.attrs.clone();
+            attrs.extend(combination_attr.clone());
+            fields.push(InitializerField {
+                attrs,
+                kind: InitializerKind::Value {
+                    member: Member::Unnamed(Index {
+                        index: active_index,
+                        span: tuple_field.value.span(),
+                    }),
+                    value: Some((
+                        Token![:](tuple_field.value.span()),
+                        tuple_field.value.clone(),
+                    )),
+                },
+            });
+            active_index += 1;
+        }
     }
     Ok((paren_token.span.close(), fields))
 }

internal/src/pin_data.rs

@@ -7,8 +7,8 @@ use syn::{
     parse_quote, parse_quote_spanned,
     spanned::Spanned,
     visit_mut::VisitMut,
-    Field, Fields, Generics, Ident, Index, Item, Member, PathSegment, Type, TypePath,
-    Visibility, WhereClause,
+    Attribute, Field, Fields, Generics, Ident, Index, Item, Member, Meta, PathSegment, Type,
+    TypePath, Visibility, WhereClause,
 };
 
 use crate::diagnostics::{DiagCtxt, ErrorGuaranteed};
@@ -56,6 +56,15 @@ fn member_display_name(member: &Member) -> String {
     }
 }
 
+fn cfg_condition(attrs: &[Attribute]) -> Option<TokenStream> {
+    let cfgs: Vec<_> = attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("cfg"))
+        .filter_map(|attr| attr.parse_args::<Meta>().ok())
+        .collect();
+    (!cfgs.is_empty()).then(|| quote!(all(#(#cfgs),*)))
+}
+
 pub(crate) fn pin_data(
     args: Args,
     input: Item,
@@ -309,6 +318,12 @@ fn generate_projections(
         .map(|f| format!(" - {}", member_display_name(&f.member)));
     let docs = format!(" Pin-projections of [`{ident}`]");
 
+    let needs_unreachable_allow = is_tuple_struct
+        && fields
+            .iter()
+            .any(|f| cfg_condition(&f.field.attrs).is_some());
+    let unreachable_allow = needs_unreachable_allow.then(|| quote!(#[allow(unreachable_code)]));
+
     let (projection_def, projection_init) = if !is_tuple_struct {
         let (fields_decl, fields_proj): (Vec<_>, Vec<_>) = fields
             .iter()
@@ -368,9 +383,12 @@ fn generate_projections(
         let mut fields_decl = Vec::new();
         let mut field_bindings = Vec::new();
         let mut field_projections = Vec::new();
+        let mut cfg_conditions = Vec::new();
+
         for (index, field) in fields.iter().enumerate() {
             let Field { vis, ty, attrs, .. } = &field.field;
             let binding = format_ident!("__field_{index}");
+            let cfg_condition = cfg_condition(attrs);
 
             if field.pinned {
                 fields_decl.push(quote!(
@@ -389,8 +407,79 @@ fn generate_projections(
                 field_projections.push(quote!(#binding,));
             }
             field_bindings.push(quote!(ref mut #binding,));
+            cfg_conditions.push(cfg_condition);
         }
 
+        let conditional_fields: Vec<_> = cfg_conditions
+            .iter()
+            .enumerate()
+            .filter_map(|(index, cfg)| cfg.as_ref().map(|cfg| (index, cfg)))
+            .collect();
+        let combinations = 1usize << conditional_fields.len();
+        let mut projection_bodies = Vec::new();
+
+        // We cannot evaluate user cfgs inside the proc macro. Instead, generate one arm per
+        // cfg combination and let rustc keep the active tuple pattern.
+        for combination in 0..combinations {
+            let cfgs: Vec<_> = conditional_fields
+                .iter()
+                .enumerate()
+                .map(|(bit, (_, cfg))| {
+                    if combination & (1 << bit) == 0 {
+                        quote!(not(#cfg))
+                    } else {
+                        quote!(#cfg)
+                    }
+                })
+                .collect();
+            let cfg_attr = (!cfgs.is_empty()).then(|| quote!(#[cfg(all(#(#cfgs),*))]));
+
+            let mut patterns = Vec::new();
+            let mut projections = Vec::new();
+            for (index, binding) in field_bindings.iter().enumerate() {
+                let included = match cfg_conditions[index] {
+                    None => true,
+                    Some(_) => {
+                        let bit = conditional_fields
+                            .iter()
+                            .position(|(field_index, _)| *field_index == index)
+                            .expect("cfg-bearing field must be present");
+                        combination & (1 << bit) != 0
+                    }
+                };
+                if included {
+                    patterns.push(binding);
+                    projections.push(&field_projections[index]);
+                }
+            }
+
+            projection_bodies.push(quote! {
+                #cfg_attr
+                {
+                    let #ident(#(#patterns)*) = *#this;
+                    return #projection(
+                        #(#projections)*
+                        ::core::marker::PhantomData,
+                    );
+                }
+            });
+        }
+        let projection_init = if conditional_fields.is_empty() {
+            quote! {{
+                let #ident(#(#field_bindings)*) = *#this;
+                #projection(
+                    #(#field_projections)*
+                    ::core::marker::PhantomData,
+                )
+            }}
+        } else {
+            quote! {{
+                #(#projection_bodies)*
+                #[allow(unreachable_code)]
+                ::core::unreachable!()
+            }}
+        };
+
         (
             quote! {
                 #[doc = #docs]
@@ -401,13 +490,7 @@ fn generate_projections(
                     ::core::marker::PhantomData<&'__pin mut ()>,
                 ) #whr;
             },
-            quote! {{
-                let #ident(#(#field_bindings)*) = *#this;
-                #projection(
-                    #(#field_projections)*
-                    ::core::marker::PhantomData,
-                )
-            }},
+            projection_init,
         )
     };
 
@@ -425,6 +508,7 @@ fn generate_projections(
             /// These fields are **not** structurally pinned:
             #(#[doc = #not_structurally_pinned_fields_docs])*
             #[inline]
+            #unreachable_allow
             #vis fn project<'__pin>(
                 self: ::core::pin::Pin<&'__pin mut Self>,
             ) -> #projection #ty_generics_with_pin_lt {
@@ -465,9 +549,8 @@ fn generate_the_pin_data(
                     /// # Safety
                     ///
                     /// - `slot` is valid and properly aligned.
-                    /// - `(*slot).#field_name` is properly aligned.
-                    /// - `(*slot).#field_name` points to uninitialized and exclusively accessed
-                    ///   memory.
+                    /// - The field is properly aligned.
+                    /// - The field points to uninitialized and exclusively accessed memory.
                     #(#attrs)*
                     #[inline(always)]
                     #vis unsafe fn #field_name(

tests/cfgs.rs

@@ -1,4 +1,6 @@
-use pin_init::{pin_data, pin_init, PinInit};
+use core::{marker::PhantomPinned, pin::Pin};
+
+use pin_init::{pin_data, pin_init, stack_pin_init, PinInit};
 
 #[pin_data]
 pub struct Struct {
@@ -21,9 +23,88 @@ impl Struct {
 
 struct Field {}
 
+fn assert_pinned<T>(_: Pin<&mut T>) {}
+
 #[pin_data]
 pub struct Struct2 {
     // Test for cases where the type is not even defined when cfg is not satisfied.
     #[cfg(any())]
     non_exist: NonExistentType,
 }
+
+#[pin_data]
+pub struct TupleStruct(#[cfg(any())] HiddenField, Field, #[pin] PhantomPinned);
+
+impl TupleStruct {
+    pub fn new() -> impl PinInit<Self> {
+        pin_init!(Self(Field {}, PhantomPinned))
+    }
+}
+
+#[allow(dead_code)]
+struct HiddenField;
+
+#[test]
+fn tuple_struct_reindexes_cfgd_out_fields() {
+    stack_pin_init!(let value = TupleStruct::new());
+    let projected = value.as_mut().project();
+    let _ = projected.0;
+    assert_pinned(projected.1);
+}
+
+#[pin_data]
+pub struct ConstructorCfgTuple(#[cfg(any())] HiddenField, Field, #[pin] PhantomPinned);
+
+impl ConstructorCfgTuple {
+    pub fn new() -> impl PinInit<Self> {
+        pin_init!(Self(
+            #[cfg(any())]
+            HiddenField,
+            Field {},
+            PhantomPinned
+        ))
+    }
+}
+
+#[test]
+fn tuple_constructor_reindexes_cfgd_out_arguments() {
+    stack_pin_init!(let value = ConstructorCfgTuple::new());
+    let projected = value.as_mut().project();
+    let _ = projected.0;
+    assert_pinned(projected.1);
+}
+
+#[pin_data]
+pub struct FeatureTupleStruct(
+    #[cfg(not(feature = "std"))] HiddenField,
+    Field,
+    #[pin] PhantomPinned,
+);
+
+impl FeatureTupleStruct {
+    pub fn new() -> impl PinInit<Self> {
+        pin_init!(Self(
+            #[cfg(not(feature = "std"))]
+            HiddenField,
+            Field {},
+            PhantomPinned
+        ))
+    }
+}
+
+#[test]
+fn tuple_struct_reindexes_feature_cfgd_out_fields() {
+    stack_pin_init!(let value = FeatureTupleStruct::new());
+    let projected = value.as_mut().project();
+    #[cfg(feature = "std")]
+    {
+        let _ = projected.0;
+        assert_pinned(projected.1);
+    }
+    #[cfg(not(feature = "std"))]
+    {
+        let _ = projected.0;
+        let _ = projected.1;
+        assert_pinned(projected.2);
+    }
+}

tests/ui/expand/many_generics.expanded.rs

@@ -95,9 +95,8 @@ const _: () = {
         /// # Safety
         ///
         /// - `slot` is valid and properly aligned.
-        /// - `(*slot).#field_name` is properly aligned.
-        /// - `(*slot).#field_name` points to uninitialized and exclusively accessed
-        ///   memory.
+        /// - The field is properly aligned.
+        /// - The field points to uninitialized and exclusively accessed memory.
         #[inline(always)]
         unsafe fn array(
             self,
@@ -111,9 +110,8 @@ const _: () = {
         /// # Safety
         ///
         /// - `slot` is valid and properly aligned.
-        /// - `(*slot).#field_name` is properly aligned.
-        /// - `(*slot).#field_name` points to uninitialized and exclusively accessed
-        ///   memory.
+        /// - The field is properly aligned.
+        /// - The field points to uninitialized and exclusively accessed memory.
         #[inline(always)]
         unsafe fn r(
             self,
@@ -127,9 +125,8 @@ const _: () = {
         /// # Safety
         ///
         /// - `slot` is valid and properly aligned.
-        /// - `(*slot).#field_name` is properly aligned.
-        /// - `(*slot).#field_name` points to uninitialized and exclusively accessed
-        ///   memory.
+        /// - The field is properly aligned.
+        /// - The field points to uninitialized and exclusively accessed memory.
         #[inline(always)]
         unsafe fn _pin(
             self,