internal: support cfg on final tuple fields and arguments

mqqz · mqqz · commit 2d2042eb7bc4 · 2026-05-25T19:31:01.000+03:00
Support tuple structs whose final field or final constructor argument is removed by #[cfg]. This preserves tuple indices without needing to evaluate user cfgs in the proc macro.

Reject #[cfg] on earlier tuple fields and tuple constructor arguments, because those cases would require reindexing the remaining fields after cfg stripping. That is possible to generate, but the extra complexity is not justified for the tuple struct support added here.

Add regression tests for the supported final-field case and UI diagnostics for the unsupported index-shifting cases.

Signed-off-by: Mohamad Alsadhan &lt;mo@sdhn.cc&gt;
diff --git a/internal/src/init.rs b/internal/src/init.rs
@@ -434,7 +434,25 @@ 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 mut fields = Punctuated::new();
+
+    for tuple_field in tuple_fields
+        .iter()
+        .take(tuple_fields.len().saturating_sub(1))
+    {
+        if let Some(attr) = tuple_field
+            .attrs
+            .iter()
+            .find(|attr| attr.path().is_ident("cfg"))
+        {
+            return Err(syn::Error::new_spanned(
+                attr,
+                "`#[cfg]` on tuple constructor arguments is only supported on the last argument",
+            ));
+        }
+    }
+
     for (index, tuple_field) in tuple_fields.into_iter().enumerate() {
         fields.push(InitializerField {
             attrs: tuple_field.attrs,
diff --git a/internal/src/pin_data.rs b/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,19 @@ fn member_display_name(member: &Member) -> String {
     }
 }
 
+fn has_cfg_attr(attrs: &[Attribute]) -> bool {
+    attrs.iter().any(|attr| attr.path().is_ident("cfg"))
+}
+
+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,
@@ -119,6 +132,17 @@ pub(crate) fn pin_data(
         })
         .collect();
 
+    if is_tuple_struct {
+        for field in fields.iter().take(fields.len().saturating_sub(1)) {
+            if has_cfg_attr(&field.field.attrs) {
+                return Err(dcx.error(
+                    field.field,
+                    "`#[cfg]` on tuple struct fields is only supported on the last field",
+                ));
+            }
+        }
+    }
+
     for field in &fields {
         if !field.pinned && is_phantom_pinned(&field.field.ty) {
             dcx.warn(
@@ -368,6 +392,7 @@ fn generate_projections(
         let mut fields_decl = Vec::new();
         let mut field_bindings = Vec::new();
         let mut field_projections = Vec::new();
+
         for (index, field) in fields.iter().enumerate() {
             let Field { vis, ty, attrs, .. } = &field.field;
             let binding = format_ident!("__field_{index}");
@@ -390,6 +415,43 @@ fn generate_projections(
             }
             field_bindings.push(quote!(ref mut #binding,));
         }
+        let projection_init = if let Some(last_field) = fields.last() {
+            if let Some(cfg) = cfg_condition(&last_field.field.attrs) {
+                let field_bindings_without_last = &field_bindings[..field_bindings.len() - 1];
+                let field_projections_without_last =
+                    &field_projections[..field_projections.len() - 1];
+                quote! {{
+                    #[cfg(#cfg)]
+                    {
+                        let #ident(#(#field_bindings)*) = *#this;
+                        #projection(
+                            #(#field_projections)*
+                            ::core::marker::PhantomData,
+                        )
+                    }
+                    #[cfg(not(#cfg))]
+                    {
+                        let #ident(#(#field_bindings_without_last)*) = *#this;
+                        #projection(
+                            #(#field_projections_without_last)*
+                            ::core::marker::PhantomData,
+                        )
+                    }
+                }}
+            } else {
+                quote! {{
+                    let #ident(#(#field_bindings)*) = *#this;
+                    #projection(
+                        #(#field_projections)*
+                        ::core::marker::PhantomData,
+                    )
+                }}
+            }
+        } else {
+            quote! {
+                #projection(::core::marker::PhantomData)
+            }
+        };
 
         (
             quote! {
@@ -401,13 +463,7 @@ fn generate_projections(
                     ::core::marker::PhantomData<&'__pin mut ()>,
                 ) #whr;
             },
-            quote! {{
-                let #ident(#(#field_bindings)*) = *#this;
-                #projection(
-                    #(#field_projections)*
-                    ::core::marker::PhantomData,
-                )
-            }},
+            projection_init,
         )
     };
 
diff --git a/tests/cfgs.rs b/tests/cfgs.rs
@@ -1,4 +1,4 @@
-use pin_init::{pin_data, pin_init, PinInit};
+use pin_init::{pin_data, pin_init, stack_pin_init, PinInit};
 
 #[pin_data]
 pub struct Struct {
@@ -21,9 +21,80 @@ impl Struct {
 
 struct Field {}
 
+#[cfg(not(feature = "std"))]
+fn assert_pinned<T>(_: core::pin::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(Field, #[cfg(any())] HiddenField);
+
+impl TupleStruct {
+    pub fn new() -> impl PinInit<Self> {
+        pin_init!(Self(Field {}))
+    }
+}
+
+#[allow(dead_code)]
+struct HiddenField;
+
+#[test]
+fn tuple_struct_allows_cfgd_out_last_field() {
+    stack_pin_init!(let value = TupleStruct::new());
+    let projected = value.as_mut().project();
+    let _ = projected.0;
+}
+
+#[pin_data]
+pub struct ConstructorCfgTuple(Field, #[cfg(any())] HiddenField);
+
+impl ConstructorCfgTuple {
+    pub fn new() -> impl PinInit<Self> {
+        pin_init!(Self(
+            Field {},
+            #[cfg(any())]
+            HiddenField
+        ))
+    }
+}
+
+#[test]
+fn tuple_constructor_allows_cfgd_out_last_argument() {
+    stack_pin_init!(let value = ConstructorCfgTuple::new());
+    let projected = value.as_mut().project();
+    let _ = projected.0;
+}
+
+#[pin_data]
+pub struct FeatureTupleStruct(
+    Field,
+    #[cfg(not(feature = "std"))]
+    #[pin]
+    core::marker::PhantomPinned,
+);
+
+impl FeatureTupleStruct {
+    pub fn new() -> impl PinInit<Self> {
+        pin_init!(Self(
+            Field {},
+            #[cfg(not(feature = "std"))]
+            core::marker::PhantomPinned
+        ))
+    }
+}
+
+#[test]
+fn tuple_struct_allows_feature_cfgd_out_last_field() {
+    stack_pin_init!(let value = FeatureTupleStruct::new());
+    let projected = value.as_mut().project();
+    let _ = projected.0;
+    #[cfg(not(feature = "std"))]
+    {
+        assert_pinned(projected.1);
+    }
+}
diff --git a/tests/ui/compile-fail/init/tuple_constructor_cfg_non_last.rs b/tests/ui/compile-fail/init/tuple_constructor_cfg_non_last.rs
@@ -0,0 +1,12 @@
+use pin_init::*;
+
+#[pin_data]
+struct Tuple(Option<i32>, i32);
+
+fn main() {
+    let _ = pin_init!(Tuple(
+        #[cfg(any())]
+        None,
+        1
+    ));
+}
diff --git a/tests/ui/compile-fail/init/tuple_constructor_cfg_non_last.stderr b/tests/ui/compile-fail/init/tuple_constructor_cfg_non_last.stderr
@@ -0,0 +1,5 @@
+error: `#[cfg]` on tuple constructor arguments is only supported on the last argument
+ --> tests/ui/compile-fail/init/tuple_constructor_cfg_non_last.rs:8:9
+  |
+8 |         #[cfg(any())]
+  |         ^^^^^^^^^^^^^
diff --git a/tests/ui/compile-fail/pin_data/tuple_struct_cfg_non_last.rs b/tests/ui/compile-fail/pin_data/tuple_struct_cfg_non_last.rs
@@ -0,0 +1,6 @@
+use pin_init::*;
+
+#[pin_data]
+struct Tuple(#[cfg(any())] HiddenField, i32);
+
+fn main() {}
diff --git a/tests/ui/compile-fail/pin_data/tuple_struct_cfg_non_last.stderr b/tests/ui/compile-fail/pin_data/tuple_struct_cfg_non_last.stderr
@@ -0,0 +1,5 @@
+error: `#[cfg]` on tuple struct fields is only supported on the last field
+ --> tests/ui/compile-fail/pin_data/tuple_struct_cfg_non_last.rs:4:14
+  |
+4 | struct Tuple(#[cfg(any())] HiddenField, i32);
+  |              ^^^^^^^^^^^^^^^^^^^^^^^^^
