Support nested flexible array members

Add support for structs where the last field is itself a struct
containing a flexible array member (FAM). For example:

    struct Name {
        int count;
        char name[];
    };

    struct Field {
        int id;
        struct Name name;  // Last field has a FAM
    };

The Name struct is generated with a generic FAM parameter:

    pub struct Name<FAM: ?Sized = [c_char; 0]> {
        pub count: c_int,
        pub name: FAM,
    }

And Field propagates this parameter to its nested field:

    pub struct Field<FAM: ?Sized = [c_char; 0]> {
        pub id: c_int,
        pub name: Name<FAM>,
    }

For packed structs, the nested FAM field is wrapped in ManuallyDrop
since packed structs cannot directly contain DST fields:

    #[repr(C, packed)]
    pub struct FieldPacked<FAM: ?Sized = [c_char; 0]> {
        pub id: c_int,
        pub name: ::std::mem::ManuallyDrop<Name<FAM>>,
    }

Implementation:
- Enhanced flex_array_member() in ir/comp.rs to recursively detect
  when a struct's last field is a compound type with its own FAM
- Updated field code generation to parameterize nested FAM field
  types with <FAM> and wrap in ManuallyDrop for packed structs
- Added test cases for nested FAMs in both regular and packed structs

Related to #2936

Author: jsgf

bindgen-tests/tests/expectations/tests/nested_flexarray.rs

@@ -0,0 +1,19 @@
+// bindgen-flags: --rust-target nightly --flexarray-dst --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(ptr_metadata, layout_for_ptr)]'
+
+// Test for nested flexible array members
+struct Field {
+    int count;
+    int data[];  // FAM
+};
+
+struct Name {
+    int id;
+    struct Field field;  // Last field is a struct with FAM
+};
+
+#pragma pack(1)
+struct NamePacked {
+    int id;
+    struct Field field;  // Last field is a struct with FAM, in a packed struct
+};
+#pragma pack()

bindgen-tests/tests/headers/nested_flexarray.hpp

@@ -1540,6 +1540,28 @@ impl FieldCodegen<'_> for FieldData {
                     syn::parse_quote! { __IncompleteArrayField<#inner> }
                 }
             }
+        } else if let TypeKind::Comp(ref comp) = field_ty.kind() {
+            // Nested FAM: the field is a struct that itself has a FAM
+            // Only treat as FAM if it's the last field
+            if ctx.options().flexarray_dst &&
+                last_field &&
+                comp.flex_array_member(ctx).is_some()
+            {
+                let layout = parent_item.expect_type().layout(ctx);
+                let is_packed = parent.is_packed(ctx, layout.as_ref());
+                struct_layout.saw_flexible_array();
+
+                // For nested FAMs, we need to parameterize the field type with FAM
+                // For packed structs, wrap in ManuallyDrop
+                if is_packed {
+                    let prefix = ctx.trait_prefix();
+                    syn::parse_quote! { ::#prefix::mem::ManuallyDrop<#ty<FAM>> }
+                } else {
+                    syn::parse_quote! { #ty<FAM> }
+                }
+            } else {
+                ty
+            }
         } else {
             ty
         };

bindgen/codegen/mod.rs

@@ -790,6 +790,10 @@ impl CompFields {
     }
 
     /// Return the flex array member for the struct/class, if any.
+    ///
+    /// This method recursively checks if the last field is either:
+    /// 1. An incomplete array (direct FAM)
+    /// 2. A struct/union that itself has a FAM (nested FAM)
     fn flex_array_member(&self, ctx: &BindgenContext) -> Option<TypeId> {
         let fields = match self {
             CompFields::Before(_) => panic!("raw fields"),
@@ -799,10 +803,23 @@ impl CompFields {
 
         match fields.last()? {
             Field::Bitfields(..) => None,
-            Field::DataMember(FieldData { ty, .. }) => ctx
-                .resolve_type(*ty)
-                .is_incomplete_array(ctx)
-                .map(|item| item.expect_type_id(ctx)),
+            Field::DataMember(FieldData { ty, .. }) => {
+                let resolved_ty = ctx.resolve_type(*ty);
+
+                // Check if it's an incomplete array first
+                if let Some(item) = resolved_ty.is_incomplete_array(ctx) {
+                    return Some(item.expect_type_id(ctx));
+                }
+
+                // Check if it's a compound type with a FAM (need to resolve through type refs)
+                let canonical_ty = resolved_ty.canonical_type(ctx);
+                if let super::ty::TypeKind::Comp(ref comp) = canonical_ty.kind()
+                {
+                    return comp.flex_array_member(ctx);
+                }
+
+                None
+            }
         }
     }
 }