Skip to main content

miniextendr_macros/dataframe_derive/
enum_expansion.rs

1//! Enum-specific DataFrame derive expansion.
2//!
3//! Generates a companion struct where every column is `Vec<Option<T>>`, with
4//! `None` fill for fields absent in a given variant.
5
6use proc_macro2::TokenStream;
7use quote::{ToTokens, format_ident, quote};
8use syn::{DeriveInput, Fields};
9
10use super::{
11    ColumnRegistry, DataFrameAttrs, EnumAutoExpandVecData, EnumExpandedFixedData,
12    EnumExpandedVecData, EnumMapFieldData, EnumResolvedField, EnumSingleFieldData,
13    EnumStructFieldData, FieldTypeKind, ResolvedColumn, SPELL_TYPES_ALIKE, VariantInfo,
14    VariantShape, borrowed_string_column, classify_field_type, column_local, column_str,
15    companion_debug_clone, companion_lifetime_marker, conditional_where, datetime_column_ty,
16    datetime_feature_assertions, expanded_elem_idents, field_is_borrowed_ref, fixed_array_elems,
17    from_rows_par_override, is_bare_reader_scalar_ty, is_datetime_ty, is_raw_scalar_ty,
18    is_reader_scalar_ty, list_column_fn, option_payload, owned_elems_iter, parallel_columns_impl,
19    parse_field_attrs, raw_na_column_error, same_column_type, width_elems,
20};
21use crate::naming;
22use crate::type_inspect::type_display;
23use std::collections::HashMap;
24
25/// Derive `DataFrameRow` for an enum with `#[dataframe(align)]`.
26///
27/// Generates a companion struct where every column is `Vec<Option<T>>`, with
28/// `None` fill for fields absent in a given variant. This is the enum counterpart
29/// of [`super::derive_struct_dataframe`].
30///
31/// # Generated items
32///
33/// - Companion struct `{Name}DataFrame` with `Vec<Option<T>>` columns (field-name union)
34/// - Optional `_tag: Vec<String>` column for variant discrimination
35/// - `impl IntoDataFrame` (companion → R data.frame) and `impl ColumnarFrame`
36///   (rows ↔ the pure-Rust companion: `from_rows` / `from_rows_par`)
37/// - `impl From<Vec<Enum>>` (sequential row->column transposition)
38/// - `impl DataFrameRowSplit` on the enum — the split
39///   (one-`data.frame`-per-variant) representation, surfaced as
40///   `rows.into_dataframe_split()` via `IntoDataFrameSplit`'s blanket impl
41///
42/// The write/read verbs are the trait surface — `rows.into_dataframe()?`
43/// (`IntoDataFrame` / `AsDataFrameExt`), `rows.into_dataframe_split()`
44/// (`IntoDataFrameSplit`), `Vec::<Row>::from_dataframe(&df)?`
45/// (`FromDataFrame`) or the one-call `Row::try_from_dataframe(sexp)` reader, and the
46/// pure-Rust `ColumnarFrame` companion verbs. The row type keeps two `#[doc(hidden)]`
47/// helpers: `to_dataframe(rows) -> companion` for the nested-companion write path
48/// (`Inner::to_dataframe(..)` without naming the inner companion type) and
49/// `to_dataframe_split(rows)`, the body holder behind the `DataFrameRowSplit` bridge.
50///
51/// # Variant support
52///
53/// - Named variants (`{ field: T }`): fields contribute by name to the unified schema
54/// - Tuple variants (`(T, U)`): fields are named `_0`, `_1`, etc.
55/// - Unit variants: contribute no columns (only tag if present)
56///
57/// # Auto-expand fields
58///
59/// Fields with `#[dataframe(expand)]` on `Vec<T>` types get dynamic column counts
60/// determined at runtime from the maximum row length across all rows. These are
61/// tracked separately from the static [`ColumnRegistry`].
62///
63/// Returns `Err` if the enum has no variants or if type conflicts arise without
64/// `#[dataframe(conflicts = "string")]`.
65pub(super) fn derive_enum_dataframe(
66    row_name: &syn::Ident,
67    input: &DeriveInput,
68    data: &syn::DataEnum,
69    df_name: &syn::Ident,
70    attrs: &DataFrameAttrs,
71) -> syn::Result<TokenStream> {
72    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
73
74    // region: Validate variants
75    if data.variants.is_empty() {
76        return Err(syn::Error::new_spanned(
77            row_name,
78            "DataFrameRow requires at least one variant",
79        ));
80    }
81
82    let mut variant_infos: Vec<VariantInfo> = Vec::new();
83
84    for variant in &data.variants {
85        match &variant.fields {
86            Fields::Named(fields) => {
87                let mut resolved = Vec::new();
88                let mut skipped = Vec::new();
89                for f in &fields.named {
90                    let fa = parse_field_attrs(f)?;
91                    let rust_name = f.ident.as_ref().unwrap().clone();
92                    if fa.skip {
93                        skipped.push(rust_name);
94                        continue;
95                    }
96                    let col_name_str = fa
97                        .rename
98                        .unwrap_or_else(|| crate::naming::ident_name(&rust_name));
99                    let binding = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&rust_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__v_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__v_{}", crate::naming::unraw(&rust_name));
100
101                    if fa.as_list {
102                        // Struct-typed fields with `as_list` must be converted via `into_list()`
103                        // at `into_data_frame` time. We keep the original Rust type in the
104                        // companion struct (so no R API is called during row accumulation) and
105                        // flag `needs_into_list = true` to trigger per-element conversion in the
106                        // dynamic `into_data_frame` path.
107                        //
108                        // Use `.as_ref().ok()` to suppress classification errors: `as_list` is
109                        // an explicit opt-in, so wrapper types (Option<T>, Arc<T>, …) are
110                        // allowed — they become opaque list-columns.
111                        let needs_into_list = #[allow(non_exhaustive_omitted_patterns)] match classify_field_type(&f.ty).as_ref().ok()
    {
    Some(FieldTypeKind::Struct { .. }) => true,
    _ => false,
}matches!(
112                            classify_field_type(&f.ty).as_ref().ok(),
113                            Some(FieldTypeKind::Struct { .. })
114                        );
115                        resolved.push(EnumResolvedField::Single(Box::new(EnumSingleFieldData {
116                            col_name: crate::naming::name_ident(&col_name_str),
117                            binding: binding.clone(),
118                            rust_name: rust_name.clone(),
119                            ty: f.ty.clone(),
120                            needs_into_list,
121                            is_factor: false,
122                        })));
123                    } else if fa.as_factor {
124                        super::validate_factor_field_type(&f.ty)?;
125                        resolved.push(EnumResolvedField::Single(Box::new(EnumSingleFieldData {
126                            col_name: crate::naming::name_ident(&col_name_str),
127                            binding: binding.clone(),
128                            rust_name: rust_name.clone(),
129                            ty: f.ty.clone(),
130                            needs_into_list: false,
131                            is_factor: true,
132                        })));
133                    } else {
134                        if let Some(error) =
135                            raw_variant_column_error(&f.ty, fa.width.is_some() || fa.expand)
136                        {
137                            return Err(error);
138                        }
139                        match classify_field_type(&f.ty)? {
140                            FieldTypeKind::FixedArray(elem_ty, len) => {
141                                resolved.push(EnumResolvedField::ExpandedFixed(Box::new(
142                                    EnumExpandedFixedData {
143                                        base_name: col_name_str,
144                                        binding: binding.clone(),
145                                        rust_name: rust_name.clone(),
146                                        elem_ty: elem_ty.clone(),
147                                        len,
148                                        borrowed: field_is_borrowed_ref(&f.ty),
149                                    },
150                                )));
151                            }
152                            FieldTypeKind::VariableVec(elem_ty)
153                            | FieldTypeKind::BoxedSlice(elem_ty)
154                            | FieldTypeKind::BorrowedSlice(elem_ty) => {
155                                if let Some(width) = fa.width {
156                                    resolved.push(EnumResolvedField::ExpandedVec(Box::new(
157                                        EnumExpandedVecData {
158                                            base_name: col_name_str,
159                                            binding: binding.clone(),
160                                            rust_name: rust_name.clone(),
161                                            elem_ty: elem_ty.clone(),
162                                            width,
163                                            borrowed: field_is_borrowed_ref(&f.ty),
164                                        },
165                                    )));
166                                } else if fa.expand {
167                                    resolved.push(EnumResolvedField::AutoExpandVec(Box::new(
168                                        EnumAutoExpandVecData {
169                                            base_name: col_name_str,
170                                            binding: binding.clone(),
171                                            rust_name: rust_name.clone(),
172                                            elem_ty: elem_ty.clone(),
173                                            container_ty: f.ty.clone(),
174                                            borrowed: field_is_borrowed_ref(&f.ty),
175                                        },
176                                    )));
177                                } else {
178                                    resolved.push(EnumResolvedField::Single(Box::new(
179                                        EnumSingleFieldData {
180                                            col_name: crate::naming::name_ident(&col_name_str),
181                                            binding: binding.clone(),
182                                            rust_name: rust_name.clone(),
183                                            ty: f.ty.clone(),
184                                            needs_into_list: false,
185                                            is_factor: false,
186                                        },
187                                    )));
188                                }
189                            }
190                            FieldTypeKind::Map { key_ty, val_ty } => {
191                                if fa.width.is_some() {
192                                    return Err(syn::Error::new_spanned(
193                                        &f.ty,
194                                        "`width` is not valid on HashMap/BTreeMap fields",
195                                    ));
196                                }
197                                if fa.expand {
198                                    return Err(syn::Error::new_spanned(
199                                        &f.ty,
200                                        "`expand`/`unnest` is not valid on HashMap/BTreeMap fields",
201                                    ));
202                                }
203                                resolved.push(EnumResolvedField::Map(Box::new(EnumMapFieldData {
204                                    base_name: col_name_str,
205                                    binding: binding.clone(),
206                                    rust_name: rust_name.clone(),
207                                    key_ty: key_ty.clone(),
208                                    val_ty: val_ty.clone(),
209                                    map_ty: f.ty.clone(),
210                                })));
211                            }
212                            FieldTypeKind::Struct { inner_ty } => {
213                                if fa.width.is_some() {
214                                    return Err(syn::Error::new_spanned(
215                                        &f.ty,
216                                        "`width` is not valid on struct fields; use \
217                                         `#[dataframe(as_list)]` to keep as an opaque list-column",
218                                    ));
219                                }
220                                if fa.expand {
221                                    return Err(syn::Error::new_spanned(
222                                        &f.ty,
223                                        "`expand`/`unnest` is not valid on struct fields; struct \
224                                         fields flatten by default via their `DataFrameRow` impl",
225                                    ));
226                                }
227                                resolved.push(EnumResolvedField::Struct(Box::new(
228                                    EnumStructFieldData {
229                                        base_name: col_name_str,
230                                        binding: binding.clone(),
231                                        rust_name: rust_name.clone(),
232                                        inner_ty: inner_ty.clone(),
233                                    },
234                                )));
235                            }
236                            FieldTypeKind::Scalar => {
237                                resolved.push(EnumResolvedField::Single(Box::new(
238                                    EnumSingleFieldData {
239                                        col_name: crate::naming::name_ident(&col_name_str),
240                                        binding: binding.clone(),
241                                        rust_name: rust_name.clone(),
242                                        ty: f.ty.clone(),
243                                        needs_into_list: false,
244                                        is_factor: false,
245                                    },
246                                )));
247                            }
248                            FieldTypeKind::OptionScalar => {
249                                return Err(option_scalar_in_variant_error(&f.ty));
250                            }
251                        }
252                    }
253                }
254                // B1: Check for `<base>_<inner_tag>` discriminant column collision.
255                //
256                // When a Struct field `kind: Inner` is flattened, the inner enum's
257                // discriminant column (tag) is emitted under `<base>_<inner_tag>`.
258                // The inner tag is retrieved at runtime from
259                // `<Inner as DataFramePayloadFields>::TAG`; the B1 check here uses the
260                // hardcoded default `"variant"` for compile-time sibling detection because
261                // we cannot inspect inner enum attributes from the outer macro parse phase.
262                // The per-inner-field payload collision is caught separately via the
263                // `const _:` assertions emitted below (using `DataFramePayloadFields`).
264                //
265                // We detect the following cases at compile time (both using "variant"):
266                //   1. Struct field `kind: Inner` + Single/Scalar sibling named `kind_variant`
267                //   2. Struct field `kind: Inner` + another Struct sibling field renamed to
268                //      produce `kind_variant`
269                //
270                // Inner-enum-internal collision (Inner has both `tag = "X"` AND payload
271                // field `X`) is caught by the `assert_no_payload_field_collision` const
272                // assertion emitted below — no carve-out needed.
273                {
274                    // Collect every flat column name produced by non-Struct resolved fields.
275                    let flat_col_names: Vec<String> = resolved
276                        .iter()
277                        .filter_map(|r| match r {
278                            EnumResolvedField::Single(d) => Some(d.col_name.to_string()),
279                            EnumResolvedField::Map(d) => {
280                                // Map fields produce <base>_keys and <base>_values.
281                                // Neither collides with <struct>_variant unless someone
282                                // explicitly renamed to match — covered by the Struct check
283                                // via base_name.
284                                let _ = d;
285                                None
286                            }
287                            _ => None,
288                        })
289                        .collect();
290
291                    for r in &resolved {
292                        if let EnumResolvedField::Struct(struct_data) = r {
293                            // Use hardcoded "variant" for the sibling check — this is the
294                            // default inner tag. The inner-payload collision for non-default
295                            // tags is caught by assert_no_payload_field_collision below.
296                            let discriminant_col = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_variant",
                struct_data.base_name))
    })format!("{}_variant", struct_data.base_name);
297                            if flat_col_names.contains(&discriminant_col) {
298                                // Find the colliding field for a better span.
299                                let colliding_span = resolved
300                                    .iter()
301                                    .find_map(|r2| match r2 {
302                                        EnumResolvedField::Single(d)
303                                            if d.col_name == discriminant_col.as_str() =>
304                                        {
305                                            Some(d.col_name.span())
306                                        }
307                                        _ => None,
308                                    })
309                                    .unwrap_or_else(proc_macro2::Span::call_site);
310                                return Err(syn::Error::new(
311                                    colliding_span,
312                                    ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("column name collision: the flatten field `{0}` (a nested `DataFrameRow` enum) will emit a discriminant column named `{1}`, but a sibling field already produces a column with the same name. Rename the sibling field or use `#[dataframe(tag = \"...\")]` on the inner enum to choose a different discriminant column name (e.g. `#[dataframe(tag = \"type\")]` → `{0}_type`)",
                struct_data.base_name, discriminant_col))
    })format!(
313                                        "column name collision: the flatten field `{base}` \
314                                         (a nested `DataFrameRow` enum) will emit a \
315                                         discriminant column named `{disc}`, but a sibling \
316                                         field already produces a column with the same name. \
317                                         Rename the sibling field or use \
318                                         `#[dataframe(tag = \"...\")]` on the inner enum to \
319                                         choose a different discriminant column name \
320                                         (e.g. `#[dataframe(tag = \"type\")]` → `{base}_type`)",
321                                        base = struct_data.base_name,
322                                        disc = discriminant_col,
323                                    ),
324                                ));
325                            }
326                        }
327                    }
328                }
329                variant_infos.push(VariantInfo {
330                    name: variant.ident.clone(),
331                    shape: VariantShape::Named,
332                    fields: resolved,
333                    skipped_fields: skipped,
334                });
335            }
336            Fields::Unnamed(fields) => {
337                let mut resolved = Vec::new();
338                for (i, f) in fields.unnamed.iter().enumerate() {
339                    let fa = parse_field_attrs(f)?;
340                    let rust_name = match ::quote::__private::IdentFragmentAdapter(&i) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("_{}", i);
341                    if fa.skip {
342                        continue;
343                    }
344                    let col_name_str = fa
345                        .rename
346                        .unwrap_or_else(|| crate::naming::ident_name(&rust_name));
347                    let binding = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&rust_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__v_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__v_{}", crate::naming::unraw(&rust_name));
348
349                    // Tuple enum fields: same expansion logic
350                    if fa.as_list {
351                        // Use `.as_ref().ok()` to suppress classification errors: `as_list` is
352                        // an explicit opt-in, so wrapper types (Option<T>, Arc<T>, …) are
353                        // allowed — they become opaque list-columns.
354                        let needs_into_list = #[allow(non_exhaustive_omitted_patterns)] match classify_field_type(&f.ty).as_ref().ok()
    {
    Some(FieldTypeKind::Struct { .. }) => true,
    _ => false,
}matches!(
355                            classify_field_type(&f.ty).as_ref().ok(),
356                            Some(FieldTypeKind::Struct { .. })
357                        );
358                        resolved.push(EnumResolvedField::Single(Box::new(EnumSingleFieldData {
359                            col_name: crate::naming::name_ident(&col_name_str),
360                            binding,
361                            rust_name,
362                            ty: f.ty.clone(),
363                            needs_into_list,
364                            is_factor: false,
365                        })));
366                    } else if fa.as_factor {
367                        super::validate_factor_field_type(&f.ty)?;
368                        resolved.push(EnumResolvedField::Single(Box::new(EnumSingleFieldData {
369                            col_name: crate::naming::name_ident(&col_name_str),
370                            binding,
371                            rust_name,
372                            ty: f.ty.clone(),
373                            needs_into_list: false,
374                            is_factor: true,
375                        })));
376                    } else {
377                        if let Some(error) =
378                            raw_variant_column_error(&f.ty, fa.width.is_some() || fa.expand)
379                        {
380                            return Err(error);
381                        }
382                        match classify_field_type(&f.ty)? {
383                            FieldTypeKind::FixedArray(elem_ty, len) => {
384                                resolved.push(EnumResolvedField::ExpandedFixed(Box::new(
385                                    EnumExpandedFixedData {
386                                        base_name: col_name_str,
387                                        binding,
388                                        rust_name,
389                                        elem_ty: elem_ty.clone(),
390                                        len,
391                                        borrowed: field_is_borrowed_ref(&f.ty),
392                                    },
393                                )));
394                            }
395                            FieldTypeKind::VariableVec(elem_ty)
396                            | FieldTypeKind::BoxedSlice(elem_ty)
397                            | FieldTypeKind::BorrowedSlice(elem_ty) => {
398                                if let Some(width) = fa.width {
399                                    resolved.push(EnumResolvedField::ExpandedVec(Box::new(
400                                        EnumExpandedVecData {
401                                            base_name: col_name_str,
402                                            binding,
403                                            rust_name,
404                                            elem_ty: elem_ty.clone(),
405                                            width,
406                                            borrowed: field_is_borrowed_ref(&f.ty),
407                                        },
408                                    )));
409                                } else if fa.expand {
410                                    resolved.push(EnumResolvedField::AutoExpandVec(Box::new(
411                                        EnumAutoExpandVecData {
412                                            base_name: col_name_str,
413                                            binding,
414                                            rust_name,
415                                            elem_ty: elem_ty.clone(),
416                                            container_ty: f.ty.clone(),
417                                            borrowed: field_is_borrowed_ref(&f.ty),
418                                        },
419                                    )));
420                                } else {
421                                    resolved.push(EnumResolvedField::Single(Box::new(
422                                        EnumSingleFieldData {
423                                            col_name: crate::naming::name_ident(&col_name_str),
424                                            binding,
425                                            rust_name,
426                                            ty: f.ty.clone(),
427                                            needs_into_list: false,
428                                            is_factor: false,
429                                        },
430                                    )));
431                                }
432                            }
433                            FieldTypeKind::Map { key_ty, val_ty } => {
434                                if fa.width.is_some() {
435                                    return Err(syn::Error::new_spanned(
436                                        &f.ty,
437                                        "`width` is not valid on HashMap/BTreeMap fields",
438                                    ));
439                                }
440                                if fa.expand {
441                                    return Err(syn::Error::new_spanned(
442                                        &f.ty,
443                                        "`expand`/`unnest` is not valid on HashMap/BTreeMap fields",
444                                    ));
445                                }
446                                resolved.push(EnumResolvedField::Map(Box::new(EnumMapFieldData {
447                                    base_name: col_name_str,
448                                    binding,
449                                    rust_name,
450                                    key_ty: key_ty.clone(),
451                                    val_ty: val_ty.clone(),
452                                    map_ty: f.ty.clone(),
453                                })));
454                            }
455                            FieldTypeKind::Struct { inner_ty } => {
456                                if fa.width.is_some() {
457                                    return Err(syn::Error::new_spanned(
458                                        &f.ty,
459                                        "`width` is not valid on struct fields; use `#[dataframe(as_list)]` \
460                                         to keep as an opaque list-column",
461                                    ));
462                                }
463                                if fa.expand {
464                                    return Err(syn::Error::new_spanned(
465                                        &f.ty,
466                                        "`expand`/`unnest` is not valid on struct fields; struct fields \
467                                         flatten by default via their DataFrameRow impl",
468                                    ));
469                                }
470                                resolved.push(EnumResolvedField::Struct(Box::new(
471                                    EnumStructFieldData {
472                                        base_name: col_name_str,
473                                        binding,
474                                        rust_name,
475                                        inner_ty: inner_ty.clone(),
476                                    },
477                                )));
478                            }
479                            FieldTypeKind::Scalar => {
480                                resolved.push(EnumResolvedField::Single(Box::new(
481                                    EnumSingleFieldData {
482                                        col_name: crate::naming::name_ident(&col_name_str),
483                                        binding,
484                                        rust_name,
485                                        ty: f.ty.clone(),
486                                        needs_into_list: false,
487                                        is_factor: false,
488                                    },
489                                )));
490                            }
491                            FieldTypeKind::OptionScalar => {
492                                return Err(option_scalar_in_variant_error(&f.ty));
493                            }
494                        }
495                    }
496                }
497                variant_infos.push(VariantInfo {
498                    name: variant.ident.clone(),
499                    shape: VariantShape::Tuple,
500                    fields: resolved,
501                    skipped_fields: ::alloc::vec::Vec::new()vec![],
502                });
503            }
504            Fields::Unit => {
505                variant_infos.push(VariantInfo {
506                    name: variant.ident.clone(),
507                    shape: VariantShape::Unit,
508                    fields: ::alloc::vec::Vec::new()vec![],
509                    skipped_fields: ::alloc::vec::Vec::new()vec![],
510                });
511            }
512        }
513    }
514    // endregion
515
516    // region: Resolve unified schema
517    // Collect all unique column names, check type consistency.
518    // Expanded fields contribute multiple columns to the schema.
519    let coerce_to_string = attrs.conflicts.as_deref() == Some("string");
520    let string_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "std");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "string");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "String");
        _s
    })syn::parse_quote!(::std::string::String);
521    let mut registry = ColumnRegistry::new(coerce_to_string, &string_ty);
522
523    for (variant_idx, vi) in variant_infos.iter().enumerate() {
524        for erf in &vi.fields {
525            // Use the rust_name span for error reporting
526            let err_span = erf.rust_name().span();
527            match erf {
528                EnumResolvedField::Single(data) => {
529                    if data.is_factor {
530                        registry.register_factor(
531                            &data.col_name.to_string(),
532                            &data.ty,
533                            variant_idx,
534                            &vi.name,
535                            err_span,
536                        )?;
537                    } else {
538                        registry.register(
539                            &data.col_name.to_string(),
540                            &data.ty,
541                            variant_idx,
542                            &vi.name,
543                            err_span,
544                        )?;
545                    }
546                }
547                EnumResolvedField::ExpandedFixed(data) => {
548                    for i in 1..=data.len {
549                        let name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
550                        registry.register(&name, &data.elem_ty, variant_idx, &vi.name, err_span)?;
551                    }
552                }
553                EnumResolvedField::ExpandedVec(data) => {
554                    for i in 1..=data.width {
555                        let name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
556                        registry.register(&name, &data.elem_ty, variant_idx, &vi.name, err_span)?;
557                    }
558                }
559                // AutoExpandVec: not registered in ColumnRegistry (width is dynamic).
560                // Collected separately below.
561                EnumResolvedField::AutoExpandVec(..) => {}
562                EnumResolvedField::Map(data) => {
563                    let key_ty = &data.key_ty;
564                    let val_ty = &data.val_ty;
565                    let keys_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
566                    let vals_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
567                    // Column types are Vec<K> and Vec<V> respectively (used as Vec<Option<Vec<K>>>
568                    // / Vec<Option<Vec<V>>> in companion struct via ColumnRegistry wrapping).
569                    let key_vec_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "std");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&key_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<#key_ty>);
570                    let val_vec_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "std");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&val_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<#val_ty>);
571                    registry.register(&keys_name, &key_vec_ty, variant_idx, &vi.name, err_span)?;
572                    registry.register(&vals_name, &val_vec_ty, variant_idx, &vi.name, err_span)?;
573                }
574                // Struct: registers one Vec<Option<Inner>> column under base_name.
575                // Flattening into prefixed columns happens at into_data_frame() time, not here.
576                EnumResolvedField::Struct(data) => {
577                    let inner_ty = &data.inner_ty;
578                    // Register as Option<Inner>; the column in the companion struct is Vec<Option<Inner>>.
579                    registry.register(
580                        &data.base_name,
581                        inner_ty,
582                        variant_idx,
583                        &vi.name,
584                        err_span,
585                    )?;
586                }
587            }
588        }
589    }
590    let columns = registry.columns;
591    // endregion
592
593    // region: Collect auto-expand fields (per-variant, for split method)
594    struct EnumAutoExpandCol {
595        df_field: syn::Ident,
596        base_name: String,
597        elem_ty: syn::Type,
598        container_ty: syn::Type,
599        present_in: Vec<usize>,
600        first_variant: syn::Ident,
601    }
602
603    let mut auto_expand_cols: Vec<EnumAutoExpandCol> = Vec::new();
604    let mut auto_expand_index: HashMap<String, usize> = HashMap::new();
605
606    for (variant_idx, vi) in variant_infos.iter().enumerate() {
607        for erf in &vi.fields {
608            if let EnumResolvedField::AutoExpandVec(auto_data) = erf {
609                if let Some(&idx) = auto_expand_index.get(&auto_data.base_name) {
610                    let first = &auto_expand_cols[idx];
611                    let elem_match = same_column_type(&first.elem_ty, &auto_data.elem_ty);
612                    let container_match =
613                        same_column_type(&first.container_ty, &auto_data.container_ty);
614                    if !elem_match {
615                        if coerce_to_string {
616                            auto_expand_cols[idx].elem_ty = string_ty.clone();
617                        } else {
618                            return Err(syn::Error::new(
619                                auto_data.rust_name.span(),
620                                ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("type conflict for auto-expand field `{0}`: variant `{1}` has element type `{2}`, variant `{3}` has `{4}`. {5}",
                auto_data.base_name, vi.name,
                type_display(&auto_data.elem_ty), first.first_variant,
                type_display(&first.elem_ty), SPELL_TYPES_ALIKE))
    })format!(
621                                    "type conflict for auto-expand field `{}`: variant `{}` has \
622                                     element type `{}`, variant `{}` has `{}`. {}",
623                                    auto_data.base_name,
624                                    vi.name,
625                                    type_display(&auto_data.elem_ty),
626                                    first.first_variant,
627                                    type_display(&first.elem_ty),
628                                    SPELL_TYPES_ALIKE,
629                                ),
630                            ));
631                        }
632                    }
633                    if !container_match {
634                        let first = &auto_expand_cols[idx];
635                        return Err(syn::Error::new(
636                            auto_data.rust_name.span(),
637                            ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("container type mismatch for auto-expand field `{0}`: variant `{1}` has `{2}`, variant `{3}` has `{4}`; all variants must use the same container type (`Vec<T>`, `Box<[T]>`, or `&[T]`)",
                auto_data.base_name, vi.name,
                type_display(&auto_data.container_ty), first.first_variant,
                type_display(&first.container_ty)))
    })format!(
638                                "container type mismatch for auto-expand field `{}`: \
639                                 variant `{}` has `{}`, variant `{}` has `{}`; \
640                                 all variants must use the same container type \
641                                 (`Vec<T>`, `Box<[T]>`, or `&[T]`)",
642                                auto_data.base_name,
643                                vi.name,
644                                type_display(&auto_data.container_ty),
645                                first.first_variant,
646                                type_display(&first.container_ty),
647                            ),
648                        ));
649                    }
650                    auto_expand_cols[idx].present_in.push(variant_idx);
651                } else {
652                    let idx = auto_expand_cols.len();
653                    auto_expand_cols.push(EnumAutoExpandCol {
654                        df_field: crate::naming::name_ident(&auto_data.base_name),
655                        base_name: auto_data.base_name.clone(),
656                        elem_ty: auto_data.elem_ty.clone(),
657                        container_ty: auto_data.container_ty.clone(),
658                        present_in: ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [variant_idx]))vec![variant_idx],
659                        first_variant: vi.name.clone(),
660                    });
661                    auto_expand_index.insert(auto_data.base_name.clone(), idx);
662                }
663            }
664        }
665    }
666    let has_enum_auto_expand = !auto_expand_cols.is_empty();
667    // endregion
668
669    // region: Collect struct fields (for bespoke into_data_frame flatten)
670    struct EnumStructCol {
671        /// Companion struct field name (matches base_name in registry).
672        df_field: syn::Ident,
673        /// Column prefix (same as df_field, used to prefix inner col names).
674        base_name: String,
675        /// Inner type.
676        inner_ty: syn::Type,
677    }
678
679    let mut struct_cols: Vec<EnumStructCol> = Vec::new();
680    let mut struct_col_index: HashMap<String, bool> = HashMap::new();
681
682    for vi in &variant_infos {
683        for erf in &vi.fields {
684            if let EnumResolvedField::Struct(data) = erf
685                && !struct_col_index.contains_key(&data.base_name)
686            {
687                struct_col_index.insert(data.base_name.clone(), true);
688                struct_cols.push(EnumStructCol {
689                    df_field: crate::naming::name_ident(&data.base_name),
690                    base_name: data.base_name.clone(),
691                    inner_ty: data.inner_ty.clone(),
692                });
693            }
694        }
695    }
696    let has_struct_cols = !struct_cols.is_empty();
697    // endregion
698
699    // region: Collect as_list struct fields (Single fields that need per-element into_list())
700    //
701    // These are Single fields with `needs_into_list = true`: struct-typed fields that carry
702    // `#[dataframe(as_list)]`. The companion struct stores `Vec<Option<T>>` (raw Rust struct),
703    // but `into_data_frame` must convert each element via `.into_list()` before building the SEXP.
704    // We collect them so we can:
705    //   a) Force the dynamic `into_data_frame` path (they need per-element conversion, not IntoR).
706    //   b) Emit the per-element conversion in the dynamic path.
707    let mut as_list_struct_col_names: std::collections::HashSet<String> =
708        std::collections::HashSet::new();
709    for vi in &variant_infos {
710        for erf in &vi.fields {
711            if let EnumResolvedField::Single(data) = erf
712                && data.needs_into_list
713            {
714                as_list_struct_col_names.insert(data.col_name.to_string());
715            }
716        }
717    }
718    let has_as_list_struct_cols = !as_list_struct_col_names.is_empty();
719
720    // Collect factor column names (Single fields with `is_factor = true`).
721    // These are emitted via `FactorOptionVec<T>` wrapping in `into_data_frame`.
722    let mut factor_col_names: std::collections::HashSet<String> = std::collections::HashSet::new();
723    for vi in &variant_infos {
724        for erf in &vi.fields {
725            if let EnumResolvedField::Single(data) = erf
726                && data.is_factor
727            {
728                factor_col_names.insert(data.col_name.to_string());
729            }
730        }
731    }
732    let has_factor_cols = !factor_col_names.is_empty();
733    // endregion
734
735    // region: Generate companion struct
736    let has_tag = attrs.tag.is_some();
737
738    let tag_field = if has_tag {
739        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { pub _tag: ::std::vec::Vec<::std::string::String>, }
740    } else {
741        TokenStream::new()
742    };
743
744    // The column fields with their types: declared below, and bounding the
745    // companion's conditional `Debug` / `Clone`.
746    let mut column_fields: Vec<(syn::Ident, TokenStream)> = columns
747        .iter()
748        .map(|col| {
749            let ty = &col.ty;
750            (
751                col.col_name.clone(),
752                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    _s
}quote! { ::std::vec::Vec<::core::option::Option<#ty>> },
753            )
754        })
755        .collect();
756    // Auto-expand fields: Vec<Option<ContainerType>>
757    for ac in &auto_expand_cols {
758        let cty = &ac.container_ty;
759        column_fields.push((
760            ac.df_field.clone(),
761            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&cty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    _s
}quote! { ::std::vec::Vec<::core::option::Option<#cty>> },
762        ));
763    }
764    let df_fields: Vec<TokenStream> = column_fields
765        .iter()
766        .map(|(name, ty)| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { pub #name: #ty })
767        .collect();
768
769    let mut companion_fields: Vec<(syn::Ident, TokenStream)> = Vec::new();
770    if has_tag {
771        companion_fields.push((
772            ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"),
773            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::std::vec::Vec<::std::string::String> },
774        ));
775    }
776
777    companion_fields.extend(column_fields);
778    let (phantom_field, phantom_init) =
779        companion_lifetime_marker(&input.generics, &mut companion_fields);
780    let companion_debug_clone = companion_debug_clone(df_name, &input.generics, &companion_fields);
781
782    let dataframe_struct = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::__private::push_ident(&mut _s, "struct");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_field, &mut _s);
            ::quote::ToTokens::to_tokens(&phantom_field, &mut _s);
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut df_fields, i) = df_fields.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let df_fields =
                        match df_fields.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&df_fields, &mut _s);
                }
            }
            _s
        });
    ::quote::ToTokens::to_tokens(&companion_debug_clone, &mut _s);
    _s
}quote! {
783        pub struct #df_name #impl_generics #where_clause {
784            #tag_field
785            #phantom_field
786            #(#df_fields),*
787        }
788
789        #companion_debug_clone
790    };
791    // endregion
792
793    // region: Generate IntoDataFrame
794    //
795    // One generator assembles the column list for both column sources: the
796    // companion (`ColumnSource::into_column_list`, which reads `self.<col>`)
797    // and the borrowed fill (`DataFrameRowBorrow`, which reads its locals), so
798    // the two build the same frame: names, order, column types.
799    //
800    // The first "real" column for length reference. If tag exists, use _tag.
801    let length_ref = if has_tag {
802        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { self._tag.len() }
803    } else if let Some(first_col) = columns.first() {
804        let first = &first_col.col_name;
805        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&first, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { self.#first.len() }
806    } else if let Some(first_ac) = auto_expand_cols.first() {
807        let first = &first_ac.df_field;
808        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&first, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { self.#first.len() }
809    } else {
810        // No columns and no tag — degenerate case, length is 0
811        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::parse(&mut _s, "0usize");
    _s
}quote! { 0usize }
812    };
813
814    // Build the set of column names that are struct-col placeholders (to skip in normal push).
815    let struct_col_names: std::collections::HashSet<String> =
816        struct_cols.iter().map(|sc| sc.base_name.clone()).collect();
817
818    // `col` reads column `name`. With `borrowed_rows`, an auto-expand column
819    // holds slices of the rows' containers, whose elements are cloned out,
820    // instead of the containers themselves.
821    let column_list_body = |col: &dyn Fn(&syn::Ident) -> TokenStream,
822                            length_ref: TokenStream,
823                            borrowed_rows: bool|
824     -> TokenStream {
825        let tag_col = col(&::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"));
826
827        // Each pair protects its SEXP via `__scope.protect_raw` so previously-built
828        // column SEXPs survive subsequent column allocations. Pre-fix the raw
829        // `vec![(name, into_sexp(...)), ...]` left every SEXP unrooted across the
830        // next column's allocations — UAF under gctorture
831        // (reviews/2026-05-07-gctorture-audit.md).
832        let tag_pair = if let Some(ref tag_name) = attrs.tag {
833            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_name, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "protect_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoR");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&tag_col, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { (#tag_name, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#tag_col))), }
834        } else {
835            TokenStream::new()
836        };
837
838        let col_pairs: Vec<TokenStream> = columns
839            .iter()
840            .map(|c| {
841                let column = col(&c.col_name);
842                let name_str = c.col_name.to_string();
843                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&name_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "protect_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoR");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&column, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! { (#name_str, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#column))) }
844            })
845            .collect();
846
847        // Length checks for all columns
848        let length_checks: Vec<TokenStream> = columns
849            .iter()
850            .map(|c| {
851                let column = col(&c.col_name);
852                let name_str = c.col_name.to_string();
853                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "assert");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_eq_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "_n_rows");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s,
                "\"column length mismatch in {}: column `{}` has length {} but expected {}\"");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "stringify");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&name_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "_n_rows");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
854                    ::core::assert!(
855                        #column.len() == _n_rows,
856                        "column length mismatch in {}: column `{}` has length {} but expected {}",
857                        ::core::stringify!(#df_name),
858                        #name_str,
859                        #column.len(),
860                        _n_rows,
861                    );
862                }
863            })
864            .collect();
865
866        if has_enum_auto_expand || has_struct_cols || has_as_list_struct_cols || has_factor_cols {
867            // Dynamic pair building for auto-expand, struct fields, as_list struct fields,
868            // and/or as_factor fields.
869            let tag_push_pair = if let Some(ref tag_name) = attrs.tag {
870                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&tag_name, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&tag_col, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
871                    __df_pairs.push((
872                        #tag_name.to_string(),
873                        __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#tag_col)),
874                    ));
875                }
876            } else {
877                TokenStream::new()
878            };
879
880            // Static columns — skip struct-col placeholders (handled in flatten block below),
881            // as-list struct fields (handled in the per-element conversion block below),
882            // and factor columns (handled in the FactorOptionVec wrapping block below).
883            let static_pair_pushes: Vec<TokenStream> = columns
884                .iter()
885                .filter(|c| {
886                    let name_str = c.col_name.to_string();
887                    !struct_col_names.contains(&name_str)
888                        && !as_list_struct_col_names.contains(&name_str)
889                        && !factor_col_names.contains(&name_str)
890                })
891                .map(|c| {
892                    let column = col(&c.col_name);
893                    let name_str = c.col_name.to_string();
894                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&name_str, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&column, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
895                        __df_pairs.push((
896                            #name_str.to_string(),
897                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#column)),
898                        ));
899                    }
900                })
901                .collect();
902
903            // as_list struct fields: convert each element via into_list() at conversion time
904            // (not during row accumulation), producing a VECSXP list-column with NULL for absent rows.
905            // `into_option_list_column` stores each list in the rooted column as it is built,
906            // so earlier cells are never unrooted while later ones allocate (#1748).
907            let as_list_struct_pushes: Vec<TokenStream> = columns
908                .iter()
909                .filter(|c| as_list_struct_col_names.contains(&c.col_name.to_string()))
910                .map(|c| {
911                    let column = col(&c.col_name);
912                    let name_str = c.col_name.to_string();
913                    let into_option_list_column = list_column_fn(&c.ty, true);
914                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&name_str, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&into_option_list_column,
                                &mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&column, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
915                        __df_pairs.push((
916                            #name_str.to_string(),
917                            __scope.protect_raw(#into_option_list_column(#column)),
918                        ));
919                    }
920                })
921                .collect();
922
923            // as_factor columns: wrap Vec<Option<T>> in FactorOptionVec<T> before calling into_sexp.
924            // Uses the UnitEnumFactor blanket impl: impl<T: UnitEnumFactor> IntoR for FactorOptionVec<T>.
925            let factor_pair_pushes: Vec<TokenStream> = columns
926                .iter()
927                .filter(|c| factor_col_names.contains(&c.col_name.to_string()))
928                .map(|c| {
929                    let column = col(&c.col_name);
930                    let name_str = c.col_name.to_string();
931                    let ty = &c.ty;
932                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&name_str, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "factor");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "FactorOptionVec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "from");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&column, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
933                        __df_pairs.push((
934                            #name_str.to_string(),
935                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(
936                                ::miniextendr_api::factor::FactorOptionVec::<#ty>::from(#column)
937                            )),
938                        ));
939                    }
940                })
941                .collect();
942
943            let auto_expand_pair_pushes: Vec<TokenStream> = auto_expand_cols
944                .iter()
945                .map(|ac| {
946                    let column = col(&ac.df_field);
947                    let base_name_str = &ac.base_name;
948                    let elem_ty = &ac.elem_ty;
949                    let elems_iter = owned_elems_iter(
950                        &{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row_vec");
    _s
}quote! { __row_vec },
951                        field_is_borrowed_ref(&ac.container_ty) || borrowed_rows,
952                        elem_ty,
953                    );
954                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__auto");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__max");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__auto");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "filter_map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "v");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "v");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "as_ref");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "v");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "v");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "max");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "unwrap_or");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "0");
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__cols");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "0");
                    ::quote::__private::push_dot2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__max");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_underscore(&mut _s);
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "with_capacity");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "_n_rows");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "collect");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_ident(&mut _s, "__opt_vec");
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::push_ident(&mut _s, "__auto");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "__elems");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "map");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__opt_vec");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__row_vec");
                            ::quote::__private::push_or(&mut _s);
                            ::quote::ToTokens::to_tokens(&elems_iter, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__col");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::push_ident(&mut _s, "__cols");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "iter_mut");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__col");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "push");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "and_then");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "core");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "option");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Option");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "as_mut");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_and(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "mut");
                                                    ::quote::__private::push_ident(&mut _s, "__elems");
                                                    _s
                                                });
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "core");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "iter");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Iterator");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "next");
                                            ::quote::__private::push_comma(&mut _s);
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__col");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::push_ident(&mut _s, "__cols");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "enumerate");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__df_pairs");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&base_name_str, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__i");
                                            ::quote::__private::push_add(&mut _s);
                                            ::quote::__private::parse(&mut _s, "1");
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "IntoR");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_ident(&mut _s, "__col");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
955                        {
956                            let __auto = #column;
957                            let __max = __auto.iter()
958                                .filter_map(|v| v.as_ref())
959                                .map(|v| v.len())
960                                .max()
961                                .unwrap_or(0);
962                            let mut __cols: ::std::vec::Vec<::std::vec::Vec<::core::option::Option<#elem_ty>>> = (0..__max)
963                                .map(|_| ::std::vec::Vec::with_capacity(_n_rows))
964                                .collect();
965                            for __opt_vec in __auto {
966                                let mut __elems = ::core::option::Option::map(
967                                    __opt_vec,
968                                    |__row_vec| #elems_iter,
969                                );
970                                for __col in __cols.iter_mut() {
971                                    __col.push(::core::option::Option::and_then(
972                                        ::core::option::Option::as_mut(&mut __elems),
973                                        ::core::iter::Iterator::next,
974                                    ));
975                                }
976                            }
977                            for (__i, __col) in __cols.into_iter().enumerate() {
978                                __df_pairs.push((
979                                    ::std::format!("{}_{}", #base_name_str, __i + 1),
980                                    __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(__col)),
981                                ));
982                            }
983                        }
984                    }
985                })
986                .collect();
987
988            // Struct field flatten blocks: for each Vec<Option<Inner>> column, collect present
989            // rows into a dense Vec<Inner>, track presence indices, call Inner::to_dataframe,
990            // extract named columns via into_named_columns(), scatter them to full row count
991            // with None-fill, and push with prefixed names.
992            let struct_flatten_pushes: Vec<TokenStream> = struct_cols
993                .iter()
994                .map(|sc| {
995                    let column = col(&sc.df_field);
996                    let base_name_str = &sc.base_name;
997                    let inner_ty = &sc.inner_ty;
998                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__present_idx");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "usize");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__inner_rows");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__row_i");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__opt");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "enumerate");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "if");
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Some");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__inner");
                            _s
                        });
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__opt");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__present_idx");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "push");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__row_i");
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__inner_rows");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "push");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__inner");
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__inner_df");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_dataframe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__inner_rows");
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__inner_cols");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnSource");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_named_columns");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__inner_df");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__inner_col_name");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__inner_col_sexp");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::push_ident(&mut _s, "__inner_cols");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__prefixed");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&base_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__inner_col_name");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__scattered");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "convert");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "scatter_column");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__inner_col_sexp");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_and(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__present_idx");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "_n_rows");
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__df_pairs");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__prefixed");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scattered");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
999                        {
1000                            // Separate the Some/None rows — collect present rows densely
1001                            // (no Clone needed: we consume the Vec<Option<Inner>>).
1002                            let mut __present_idx: ::std::vec::Vec<usize> = ::std::vec::Vec::new();
1003                            let mut __inner_rows: ::std::vec::Vec<#inner_ty> = ::std::vec::Vec::new();
1004                            for (__row_i, __opt) in #column.into_iter().enumerate() {
1005                                if let ::core::option::Option::Some(__inner) = __opt {
1006                                    __present_idx.push(__row_i);
1007                                    __inner_rows.push(__inner);
1008                                }
1009                            }
1010                            // Call Inner::to_dataframe and extract named column SEXPs.
1011                            let __inner_df = <#inner_ty>::to_dataframe(__inner_rows);
1012                            // into_named_columns roots the inner column list in __scope, so
1013                            // every source column outlives the scatter allocations below.
1014                            let __inner_cols = ::miniextendr_api::convert::ColumnSource::into_named_columns(
1015                                __inner_df,
1016                                &__scope,
1017                            );
1018                            // Scatter each column back to full _n_rows with NA/NULL-fill,
1019                            // preserving the source column's SEXPTYPE and attributes (a factor
1020                            // stays a factor).
1021                            for (__inner_col_name, __inner_col_sexp) in __inner_cols {
1022                                let __prefixed = ::std::format!("{}_{}", #base_name_str, __inner_col_name);
1023                                let __scattered = __scope.protect_raw(
1024                                    ::miniextendr_api::convert::scatter_column(
1025                                        __inner_col_sexp,
1026                                        &__present_idx,
1027                                        _n_rows,
1028                                    ),
1029                                );
1030                                __df_pairs.push((__prefixed, __scattered));
1031                            }
1032                        }
1033                    }
1034                })
1035                .collect();
1036
1037            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "_n_rows");
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&length_ref, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut length_checks, i) = length_checks.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let length_checks =
                match length_checks.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&length_checks, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "gc_protect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ProtectScope");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__df_pairs");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "string");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "String");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::ToTokens::to_tokens(&tag_push_pair, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut static_pair_pushes, i) =
                    static_pair_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let static_pair_pushes =
                        match static_pair_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&static_pair_pushes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut factor_pair_pushes, i) =
                    factor_pair_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let factor_pair_pushes =
                        match factor_pair_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&factor_pair_pushes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut auto_expand_pair_pushes, i) =
                    auto_expand_pair_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let auto_expand_pair_pushes =
                        match auto_expand_pair_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&auto_expand_pair_pushes,
                        &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut struct_flatten_pushes, i) =
                    struct_flatten_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let struct_flatten_pushes =
                        match struct_flatten_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&struct_flatten_pushes,
                        &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut as_list_struct_pushes, i) =
                    as_list_struct_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let as_list_struct_pushes =
                        match as_list_struct_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&as_list_struct_pushes,
                        &mut _s);
                }
            }
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_raw_pairs");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__df_pairs");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_class_str");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"data.frame\"");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_row_names_int");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "_n_rows");
                    _s
                });
            _s
        });
    _s
}quote! {
1038                let _n_rows = #length_ref;
1039                #(#length_checks)*
1040                // SAFETY: the column list is only assembled on the R main thread.
1041                // ProtectScope keeps each column SEXP rooted across the
1042                // next column's allocations; from_raw_pairs writes them
1043                // into the parent VECSXP before we drop the scope.
1044                unsafe {
1045                    let __scope = ::miniextendr_api::gc_protect::ProtectScope::new();
1046                    let mut __df_pairs: ::std::vec::Vec<(
1047                        ::std::string::String,
1048                        ::miniextendr_api::SEXP,
1049                    )> = ::std::vec::Vec::new();
1050                    #tag_push_pair
1051                    #(#static_pair_pushes)*
1052                    #(#factor_pair_pushes)*
1053                    #(#auto_expand_pair_pushes)*
1054                    #(#struct_flatten_pushes)*
1055                    #(#as_list_struct_pushes)*
1056                    ::miniextendr_api::list::List::from_raw_pairs(__df_pairs)
1057                        .set_class_str(&["data.frame"])
1058                        .set_row_names_int(_n_rows)
1059                }
1060            }
1061        } else {
1062            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "_n_rows");
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&length_ref, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut length_checks, i) = length_checks.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let length_checks =
                match length_checks.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&length_checks, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "gc_protect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ProtectScope");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__pairs");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "str");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    _s
                });
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&tag_pair, &mut _s);
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut col_pairs, i) = col_pairs.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let col_pairs =
                                match col_pairs.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&col_pairs, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_raw_pairs");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__pairs");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_class_str");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"data.frame\"");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_row_names_int");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "_n_rows");
                    _s
                });
            _s
        });
    _s
}quote! {
1063                let _n_rows = #length_ref;
1064                #(#length_checks)*
1065                // SAFETY: see the auto-expand branch.
1066                unsafe {
1067                    let __scope = ::miniextendr_api::gc_protect::ProtectScope::new();
1068                    // Explicit type annotation so the vec![] case (unit-only enum
1069                    // with no columns and no tag) doesn't hit E0282 inference failure.
1070                    let __pairs: ::std::vec::Vec<(&str, ::miniextendr_api::SEXP)> = ::std::vec![
1071                        #tag_pair
1072                        #(#col_pairs),*
1073                    ];
1074                    ::miniextendr_api::list::List::from_raw_pairs(__pairs)
1075                    .set_class_str(&["data.frame"])
1076                    .set_row_names_int(_n_rows)
1077                }
1078            }
1079        }
1080    };
1081
1082    let companion_column_list = column_list_body(&|name| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    _s
}quote! { self.#name }, length_ref, false);
1083    let into_dataframe_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "convert");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ColumnSource");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "into_column_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&companion_column_list,
                        &mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
1084        impl #impl_generics ::miniextendr_api::convert::ColumnSource for #df_name #ty_generics #where_clause {
1085            fn into_column_list(self) -> ::miniextendr_api::List {
1086                #companion_column_list
1087            }
1088        }
1089    };
1090
1091    // Compile-time assertions: one per struct field, asserting the inner type
1092    // implements DataFrameRow.
1093    let struct_assertions: Vec<TokenStream> = struct_cols
1094        .iter()
1095        .map(|sc| {
1096            let inner_ty = &sc.inner_ty;
1097            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "const");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "_assert_inner_is_dataframe_row");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "T");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "markers");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameRow");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "_do_assert");
            ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s,
                        "_assert_inner_is_dataframe_row");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1098                const _: () = {
1099                    fn _assert_inner_is_dataframe_row<T: ::miniextendr_api::markers::DataFrameRow>() {}
1100                    fn _do_assert #impl_generics () #where_clause {
1101                        _assert_inner_is_dataframe_row::<#inner_ty>();
1102                    }
1103                };
1104            }
1105        })
1106        .collect();
1107    // A datetime column without its miniextendr-api feature names the feature.
1108    let datetime_assertions = datetime_feature_assertions(variant_infos.iter().flat_map(|vi| {
1109        vi.fields.iter().filter_map(|erf| match erf {
1110            EnumResolvedField::Single(d) => datetime_column_ty(&d.ty),
1111            _ => None,
1112        })
1113    }));
1114
1115    // Payload collision assertions (#486): one per nested-enum struct field.
1116    // For each `kind: Inner` field, emit:
1117    //   const _: () = ::miniextendr_api::markers::assert_no_payload_field_collision(
1118    //       <Inner as DataFramePayloadFields>::FIELDS,
1119    //       <Inner as DataFramePayloadFields>::TAG,
1120    //   );
1121    // This fires a compile-time panic if any inner payload field name equals the
1122    // inner enum's own tag suffix, which would (after outer prefix expansion) produce
1123    // a column name identical to the outer discriminant column.
1124    let payload_collision_assertions: Vec<TokenStream> = struct_cols
1125        .iter()
1126        .map(|sc| {
1127            let inner_ty = &sc.inner_ty;
1128            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "const");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "markers");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s,
        "assert_no_payload_field_collision");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "markers");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFramePayloadFields");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "FIELDS");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "markers");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFramePayloadFields");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "TAG");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1129                const _: () = ::miniextendr_api::markers::assert_no_payload_field_collision(
1130                    <#inner_ty as ::miniextendr_api::markers::DataFramePayloadFields>::FIELDS,
1131                    <#inner_ty as ::miniextendr_api::markers::DataFramePayloadFields>::TAG,
1132                );
1133            }
1134        })
1135        .collect();
1136
1137    // Sibling collision assertions (#544): one per nested-enum struct field.
1138    //
1139    // The B1 parse-time check (earlier in this function) hardcodes `"variant"` as the
1140    // inner tag when building the discriminant column name to compare against sibling
1141    // Single fields. That check covers the common case with better spans/messages.
1142    //
1143    // This const assertion covers the non-default-tag case: when `Inner` uses
1144    // `#[dataframe(tag = "foo")]`, the discriminant column is `<base>_foo`, not
1145    // `<base>_variant`. The const assertion uses `<Inner as DataFramePayloadFields>::TAG`
1146    // so it resolves to the actual tag at compile time regardless of the value.
1147    //
1148    // We collect all Single col names across ALL variants (not just the variant that
1149    // introduced the struct field) — a collision in any one variant is a bug.
1150    let all_single_col_names: Vec<String> = {
1151        let mut seen = std::collections::HashSet::new();
1152        let mut names = Vec::new();
1153        for vi in &variant_infos {
1154            for erf in &vi.fields {
1155                if let EnumResolvedField::Single(d) = erf {
1156                    let col = d.col_name.to_string();
1157                    if seen.insert(col.clone()) {
1158                        names.push(col);
1159                    }
1160                }
1161            }
1162        }
1163        names
1164    };
1165    let sibling_collision_assertions: Vec<TokenStream> = struct_cols
1166        .iter()
1167        .map(|sc| {
1168            let inner_ty = &sc.inner_ty;
1169            let base_str = &sc.base_name;
1170            let sibling_lits = all_single_col_names
1171                .iter()
1172                .map(|s| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&s, &mut _s);
    _s
}quote! { #s })
1173                .collect::<Vec<_>>();
1174            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "const");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "markers");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s,
        "assert_no_sibling_field_collision");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut sibling_lits, i) = sibling_lits.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let sibling_lits =
                                match sibling_lits.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&sibling_lits, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&base_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "markers");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFramePayloadFields");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "TAG");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1175                const _: () = ::miniextendr_api::markers::assert_no_sibling_field_collision(
1176                    &[#(#sibling_lits),*],
1177                    #base_str,
1178                    <#inner_ty as ::miniextendr_api::markers::DataFramePayloadFields>::TAG,
1179                );
1180            }
1181        })
1182        .collect();
1183    // endregion
1184
1185    // region: Generate From<Vec<Enum>>
1186    //
1187    // Both fills keep each column in a prefixed local (`column_local`), so no
1188    // column name can shadow the fill's own bindings (`rows`, `__mx_len`).
1189    let local_column = |name: &syn::Ident| -> TokenStream {
1190        let local = column_local(name);
1191        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #local }
1192    };
1193    let mut col_vec_inits: Vec<TokenStream> = columns
1194        .iter()
1195        .map(|col| {
1196            let local = column_local(&col.col_name);
1197            let ty = &col.ty;
1198            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #local: ::std::vec::Vec<::core::option::Option<#ty>> = ::std::vec::Vec::with_capacity(__mx_len); }
1199        })
1200        .collect();
1201    for ac in &auto_expand_cols {
1202        let local = column_local(&ac.df_field);
1203        let cty = &ac.container_ty;
1204        col_vec_inits.push(
1205            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&cty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #local: ::std::vec::Vec<::core::option::Option<#cty>> = ::std::vec::Vec::with_capacity(__mx_len); },
1206        );
1207    }
1208
1209    let tag_init = if has_tag {
1210        let local = column_local(&::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"));
1211        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #local: ::std::vec::Vec<::std::string::String> = ::std::vec::Vec::with_capacity(__mx_len); }
1212    } else {
1213        TokenStream::new()
1214    };
1215
1216    // The `String` columns the borrowed fill (`DataFrameRowBorrow`) writes from
1217    // the rows' `&str` (`Vec<Option<&str>>`): every plain `String` column that
1218    // only plain fields feed. Not the `conflicts = "string"` ones, whose values
1219    // are formatted anyway, nor a column an expanded field feeds in some
1220    // variant (`pair: [String; 2]` feeds `pair_1`), whose values are cloned.
1221    let expanded_col_names: std::collections::HashSet<String> = variant_infos
1222        .iter()
1223        .flat_map(|vi| &vi.fields)
1224        .flat_map(|erf| match erf {
1225            EnumResolvedField::ExpandedFixed(data) => (1..=data.len)
1226                .map(|i| ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i))
1227                .collect::<Vec<_>>(),
1228            EnumResolvedField::ExpandedVec(data) => (1..=data.width)
1229                .map(|i| ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i))
1230                .collect(),
1231            _ => Vec::new(),
1232        })
1233        .collect();
1234    let borrowed_string_cols: std::collections::HashSet<String> = columns
1235        .iter()
1236        .filter(|col| {
1237            let name_str = col.col_name.to_string();
1238            !col.string_coerced
1239                && !col.is_factor
1240                && !struct_col_names.contains(&name_str)
1241                && !as_list_struct_col_names.contains(&name_str)
1242                && !expanded_col_names.contains(&name_str)
1243                && option_payload(&col.ty).is_none()
1244                && borrowed_string_column(&col.ty).is_some()
1245        })
1246        .map(|col| col.col_name.to_string())
1247        .collect();
1248
1249    // The match arms that push one row's values into the columns. `col` names
1250    // the column vector to push into. The owned fill (`From<Vec<Enum>>`) moves
1251    // each value out of its row; the borrowed fill (`borrowed`, matching on
1252    // `&Enum`, so every binding is a reference) clones it, or borrows the
1253    // `&str` of a `String` column, and keeps an auto-expand field as a slice.
1254    let fill_arms = |borrowed: bool,
1255                     col: &dyn Fn(&syn::Ident) -> TokenStream|
1256     -> Vec<TokenStream> {
1257        let tag_col = col(&::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"));
1258        variant_infos
1259            .iter()
1260            .enumerate()
1261            .map(|(variant_idx, vi)| {
1262                let variant_name = &vi.name;
1263                let variant_name_str = variant_name.to_string();
1264
1265                let tag_push = if !has_tag {
1266                    TokenStream::new()
1267                } else if borrowed {
1268                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&tag_col, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #tag_col.push(#variant_name_str); }
1269                } else {
1270                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&tag_col, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #tag_col.push(#variant_name_str.to_string()); }
1271                };
1272
1273                // Build push statements for each schema column.
1274                // For present columns: push Some(value), for absent: push None.
1275                // Expanded fields contribute multiple columns from one binding.
1276                let col_pushes: Vec<TokenStream> = columns
1277                    .iter()
1278                    .map(|c| {
1279                        let col_name = &c.col_name;
1280                        let target = col(col_name);
1281                        if c.present_in.contains(&variant_idx) {
1282                            let col_name_str = col_name.to_string();
1283
1284                            for (pos, erf) in vi.fields.iter().enumerate() {
1285                                match erf {
1286                                    EnumResolvedField::Single(data)
1287                                        if data.col_name == *col_name =>
1288                                    {
1289                                        let binding = &data.binding;
1290                                        let value = if c.string_coerced {
1291                                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ToString");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "to_string");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&binding, &mut _s);
            _s
        });
    _s
}quote! { ::std::string::ToString::to_string(&#binding) }
1292                                        } else if !borrowed {
1293                                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding }
1294                                        } else if borrowed_string_cols.contains(&col_name_str) {
1295                                            column_str({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding })
1296                                        } else {
1297                                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&binding, &mut _s);
            _s
        });
    _s
}quote! { ::core::clone::Clone::clone(#binding) }
1298                                        };
1299                                        return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&value, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::Some(#value)); };
1300                                    }
1301                                    EnumResolvedField::ExpandedFixed(data) => {
1302                                        let elems = enum_elem_idents(pos, data.len);
1303                                        for (i, elem) in elems.iter().enumerate() {
1304                                            let expanded_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i + 1))
    })format!("{}_{}", data.base_name, i + 1);
1305                                            if expanded_name == col_name_str {
1306                                                return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&elem, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::Some(#elem)); };
1307                                            }
1308                                        }
1309                                    }
1310                                    EnumResolvedField::ExpandedVec(data) => {
1311                                        let elems = enum_elem_idents(pos, data.width);
1312                                        for (i, elem) in elems.iter().enumerate() {
1313                                            let expanded_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i + 1))
    })format!("{}_{}", data.base_name, i + 1);
1314                                            if expanded_name == col_name_str {
1315                                                return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(#elem); };
1316                                            }
1317                                        }
1318                                    }
1319                                    EnumResolvedField::Map(data) => {
1320                                        let keys_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
1321                                        let vals_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
1322                                        let binding = &data.binding;
1323                                        // Use unzip() to guarantee pairwise alignment of keys and values.
1324                                        // Both columns are emitted together when the _keys column is
1325                                        // processed; the _values column is skipped (already handled).
1326                                        if col_name_str == keys_name {
1327                                            let vals_col = col(&match ::quote::__private::IdentFragmentAdapter(&vals_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}", vals_name));
1328                                            let pairs = if borrowed {
1329                                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "IntoIterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&binding, &mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__mx_key");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__mx_val");
                    _s
                });
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__mx_key");
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__mx_val");
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    _s
}quote! {
1330                                                    ::core::iter::Iterator::map(
1331                                                        ::core::iter::IntoIterator::into_iter(#binding),
1332                                                        |(__mx_key, __mx_val)| (
1333                                                            ::core::clone::Clone::clone(__mx_key),
1334                                                            ::core::clone::Clone::clone(__mx_val),
1335                                                        ),
1336                                                    )
1337                                                }
1338                                            } else {
1339                                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #binding.into_iter() }
1340                                            };
1341                                            return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&pairs, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unzip");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__mx_keys");
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&vals_col, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__mx_vals");
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1342                                                let (__mx_keys, __mx_vals) = #pairs.unzip::<_, _, ::std::vec::Vec<_>, ::std::vec::Vec<_>>();
1343                                                #target.push(::core::option::Option::Some(__mx_keys));
1344                                                #vals_col.push(::core::option::Option::Some(__mx_vals));
1345                                            };
1346                                        }
1347                                        if col_name_str == vals_name {
1348                                            // Already handled when keys col was processed; emit no-op.
1349                                            return ::quote::__private::TokenStream::new()quote! {};
1350                                        }
1351                                    }
1352                                    // Struct field: push Some(binding) to the Vec<Option<Inner>> column.
1353                                    EnumResolvedField::Struct(data)
1354                                        if data.base_name == col_name_str =>
1355                                    {
1356                                        let binding = &data.binding;
1357                                        let value = if borrowed {
1358                                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&binding, &mut _s);
            _s
        });
    _s
}quote! { ::core::clone::Clone::clone(#binding) }
1359                                        } else {
1360                                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding }
1361                                        };
1362                                        return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&value, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::Some(#value)); };
1363                                    }
1364                                    // AutoExpandVec doesn't contribute to static columns
1365                                    _ => {}
1366                                }
1367                            }
1368                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::None); }
1369                        } else {
1370                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::None); }
1371                        }
1372                    })
1373                    .collect();
1374
1375                let elem_prelude = expanded_elem_prelude(vi, borrowed);
1376
1377                // Auto-expand push statements
1378                let auto_expand_pushes: Vec<TokenStream> = auto_expand_cols
1379                    .iter()
1380                    .map(|ac| {
1381                        let target = col(&ac.df_field);
1382                        if ac.present_in.contains(&variant_idx) {
1383                            // Find the binding for this auto-expand field
1384                            for erf in &vi.fields {
1385                                if let EnumResolvedField::AutoExpandVec(data) = erf
1386                                    && data.base_name == ac.base_name
1387                                {
1388                                    let binding = &data.binding;
1389                                    let value = if borrowed {
1390                                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&binding, &mut _s);
            _s
        });
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_dot2(&mut _s);
            _s
        });
    _s
}quote! { &(#binding)[..] }
1391                                    } else {
1392                                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding }
1393                                    };
1394                                    return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&value, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::Some(#value)); };
1395                                }
1396                            }
1397                            // shouldn't reach here
1398                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::None); }
1399                        } else {
1400                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #target.push(::core::option::Option::None); }
1401                        }
1402                    })
1403                    .collect();
1404
1405                // Generate destructure pattern based on variant shape
1406                match vi.shape {
1407                    VariantShape::Named => {
1408                        let mut field_bindings: Vec<TokenStream> = vi.fields.iter().map(|erf| {
1409                            let rust_name = erf.rust_name();
1410                            let binding = erf.binding();
1411                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #rust_name: #binding }
1412                        }).collect();
1413                        // Add skipped fields as wildcard bindings
1414                        for skipped in &vi.skipped_fields {
1415                            field_bindings.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&skipped, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    _s
}quote! { #skipped: _ });
1416                        }
1417                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut field_bindings, i) =
                    field_bindings.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let field_bindings =
                        match field_bindings.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&field_bindings, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_push, &mut _s);
            ::quote::ToTokens::to_tokens(&elem_prelude, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut col_pushes, i) = col_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let col_pushes =
                        match col_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&col_pushes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut auto_expand_pushes, i) =
                    auto_expand_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let auto_expand_pushes =
                        match auto_expand_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&auto_expand_pushes, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
1418                            #row_name::#variant_name { #(#field_bindings),* } => {
1419                                #tag_push
1420                                #elem_prelude
1421                                #(#col_pushes)*
1422                                #(#auto_expand_pushes)*
1423                            }
1424                        }
1425                    }
1426                    VariantShape::Tuple => {
1427                        let field_bindings: Vec<TokenStream> = vi.fields.iter().map(|erf| {
1428                            let binding = erf.binding();
1429                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding }
1430                        }).collect();
1431                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut field_bindings, i) =
                    field_bindings.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let field_bindings =
                        match field_bindings.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&field_bindings, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_push, &mut _s);
            ::quote::ToTokens::to_tokens(&elem_prelude, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut col_pushes, i) = col_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let col_pushes =
                        match col_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&col_pushes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut auto_expand_pushes, i) =
                    auto_expand_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let auto_expand_pushes =
                        match auto_expand_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&auto_expand_pushes, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
1432                            #row_name::#variant_name(#(#field_bindings),*) => {
1433                                #tag_push
1434                                #elem_prelude
1435                                #(#col_pushes)*
1436                                #(#auto_expand_pushes)*
1437                            }
1438                        }
1439                    }
1440                    VariantShape::Unit => {
1441                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_push, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut col_pushes, i) = col_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let col_pushes =
                        match col_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&col_pushes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut auto_expand_pushes, i) =
                    auto_expand_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let auto_expand_pushes =
                        match auto_expand_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&auto_expand_pushes, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
1442                            #row_name::#variant_name => {
1443                                #tag_push
1444                                #(#col_pushes)*
1445                                #(#auto_expand_pushes)*
1446                            }
1447                        }
1448                    }
1449                }
1450            })
1451            .collect()
1452    };
1453    let match_arms = fill_arms(false, &local_column);
1454
1455    let tag_struct_field = if has_tag {
1456        let local = column_local(&::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"));
1457        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { _tag: #local, }
1458    } else {
1459        TokenStream::new()
1460    };
1461
1462    let mut col_struct_fields: Vec<TokenStream> = columns
1463        .iter()
1464        .map(|col| {
1465            let name = &col.col_name;
1466            let local = column_local(name);
1467            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local }
1468        })
1469        .collect();
1470    for ac in &auto_expand_cols {
1471        let name = &ac.df_field;
1472        let local = column_local(name);
1473        col_struct_fields.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local });
1474    }
1475
1476    let from_vec_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "convert");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "From");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__mx_len");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&tag_init, &mut _s);
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut col_vec_inits, i) =
                            col_vec_inits.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let col_vec_inits =
                                match col_vec_inits.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::ToTokens::to_tokens(&col_vec_inits, &mut _s);
                        }
                    }
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__mx_row");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "match");
                            ::quote::__private::push_ident(&mut _s, "__mx_row");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    {
                                        use ::quote::__private::ext::*;
                                        let has_iter = ::quote::__private::HasIterator::<false>;
                                        #[allow(unused_mut)]
                                        let (mut match_arms, i) = match_arms.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let match_arms =
                                                match match_arms.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            ::quote::ToTokens::to_tokens(&match_arms, &mut _s);
                                        }
                                    }
                                    _s
                                });
                            _s
                        });
                    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&tag_struct_field, &mut _s);
                            ::quote::ToTokens::to_tokens(&phantom_init, &mut _s);
                            {
                                use ::quote::__private::ext::*;
                                let mut _first = true;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut col_struct_fields, i) =
                                    col_struct_fields.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let col_struct_fields =
                                        match col_struct_fields.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    if !_first { ::quote::__private::push_comma(&mut _s); }
                                    _first = false;
                                    ::quote::ToTokens::to_tokens(&col_struct_fields, &mut _s);
                                }
                            }
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
1477        impl #impl_generics ::core::convert::From<::std::vec::Vec<#row_name #ty_generics>> for #df_name #ty_generics #where_clause {
1478            fn from(rows: ::std::vec::Vec<#row_name #ty_generics>) -> Self {
1479                let __mx_len = rows.len();
1480                #tag_init
1481                #(#col_vec_inits)*
1482                for __mx_row in rows {
1483                    match __mx_row {
1484                        #(#match_arms)*
1485                    }
1486                }
1487                #df_name {
1488                    #tag_struct_field
1489                    #phantom_init
1490                    #(#col_struct_fields),*
1491                }
1492            }
1493        }
1494    };
1495    // endregion
1496
1497    // region: DataFrameRowBorrow — the borrowed fill (#2307)
1498    //
1499    // The owned fill's match arms over `&Enum` into locals with the companion's
1500    // column types, then the column assembly above. Plain `String` columns hold
1501    // the rows' `&str`; every other value is cloned into its column. What the
1502    // fill needs of a field type (`Clone`, `StringColumn`) is the impl's
1503    // conditional `where` clause, so a row with a non-`Clone` field still
1504    // derives: the borrowed conversion just does not apply to it.
1505    let mut borrow_inits: Vec<TokenStream> = Vec::new();
1506    if has_tag {
1507        let local = column_local(&::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"));
1508        borrow_inits.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_lifetime(&mut _s, "\'static");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "primitive");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "str");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1509            let mut #local: ::std::vec::Vec<&'static ::core::primitive::str> = ::std::vec::Vec::with_capacity(__mx_len);
1510        });
1511    }
1512    for col in &columns {
1513        let local = column_local(&col.col_name);
1514        let elem_ty = if borrowed_string_cols.contains(&col.col_name.to_string()) {
1515            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "primitive");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "str");
    _s
}quote! { &::core::primitive::str }
1516        } else {
1517            let ty = &col.ty;
1518            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }
1519        };
1520        borrow_inits.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1521            let mut #local: ::std::vec::Vec<::core::option::Option<#elem_ty>> = ::std::vec::Vec::with_capacity(__mx_len);
1522        });
1523    }
1524    for ac in &auto_expand_cols {
1525        let local = column_local(&ac.df_field);
1526        let elem_ty = &ac.elem_ty;
1527        borrow_inits.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
            _s
        });
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1528            let mut #local: ::std::vec::Vec<::core::option::Option<&[#elem_ty]>> = ::std::vec::Vec::with_capacity(__mx_len);
1529        });
1530    }
1531    let clone_bound = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    _s
}quote! { ::core::clone::Clone };
1532    let mut borrow_bounds: Vec<(TokenStream, TokenStream)> = Vec::new();
1533    for vi in &variant_infos {
1534        for erf in &vi.fields {
1535            match erf {
1536                EnumResolvedField::Single(data) => {
1537                    let col_name_str = data.col_name.to_string();
1538                    let column = columns.iter().find(|c| c.col_name == data.col_name);
1539                    if column.is_some_and(|c| c.string_coerced) {
1540                        continue;
1541                    }
1542                    let ty = &data.ty;
1543                    let bound = if borrowed_string_cols.contains(&col_name_str) {
1544                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "StringColumn");
    _s
}quote! { ::miniextendr_api::dataframe::StringColumn }
1545                    } else {
1546                        clone_bound.clone()
1547                    };
1548                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, bound));
1549                }
1550                EnumResolvedField::ExpandedFixed(data) => {
1551                    let ty = &data.elem_ty;
1552                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, clone_bound.clone()));
1553                }
1554                EnumResolvedField::ExpandedVec(data) => {
1555                    let ty = &data.elem_ty;
1556                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, clone_bound.clone()));
1557                }
1558                EnumResolvedField::AutoExpandVec(data) => {
1559                    let ty = &data.elem_ty;
1560                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, clone_bound.clone()));
1561                }
1562                EnumResolvedField::Map(data) => {
1563                    let key_ty = &data.key_ty;
1564                    let val_ty = &data.val_ty;
1565                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&key_ty, &mut _s);
    _s
}quote! { #key_ty }, clone_bound.clone()));
1566                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&val_ty, &mut _s);
    _s
}quote! { #val_ty }, clone_bound.clone()));
1567                }
1568                EnumResolvedField::Struct(data) => {
1569                    let ty = &data.inner_ty;
1570                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, clone_bound.clone()));
1571                }
1572            }
1573        }
1574    }
1575    let borrow_arms = fill_arms(true, &local_column);
1576    let borrowed_column_list = column_list_body(&local_column, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_len");
    _s
}quote! { __mx_len }, true);
1577    let borrow_where = conditional_where(where_clause, &borrow_bounds);
1578    let borrow_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "automatically_derived");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unused_lifetimes");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameRowBorrow");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&borrow_where, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "rows_ref_into_column_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "Self");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__mx_len");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "Self");
                            _s
                        });
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "rows");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut borrow_inits, i) = borrow_inits.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let borrow_inits =
                                match borrow_inits.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::ToTokens::to_tokens(&borrow_inits, &mut _s);
                        }
                    }
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__mx_row");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "match");
                            ::quote::__private::push_ident(&mut _s, "__mx_row");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    {
                                        use ::quote::__private::ext::*;
                                        let has_iter = ::quote::__private::HasIterator::<false>;
                                        #[allow(unused_mut)]
                                        let (mut borrow_arms, i) = borrow_arms.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let borrow_arms =
                                                match borrow_arms.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            ::quote::ToTokens::to_tokens(&borrow_arms, &mut _s);
                                        }
                                    }
                                    _s
                                });
                            _s
                        });
                    ::quote::ToTokens::to_tokens(&borrowed_column_list,
                        &mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
1579        #[automatically_derived]
1580        #[allow(unused_lifetimes)]
1581        impl #impl_generics ::miniextendr_api::dataframe::DataFrameRowBorrow
1582            for #row_name #ty_generics #borrow_where
1583        {
1584            fn rows_ref_into_column_list(rows: &[Self]) -> ::miniextendr_api::List {
1585                let __mx_len = <[Self]>::len(rows);
1586                #(#borrow_inits)*
1587                for __mx_row in rows {
1588                    match __mx_row {
1589                        #(#borrow_arms)*
1590                    }
1591                }
1592                #borrowed_column_list
1593            }
1594        }
1595    };
1596    // endregion
1597
1598    // region: Generate from_rows_par (parallel scatter-write via ColumnWriter)
1599    //
1600    // The companion's `ParallelColumns` impl moves each row to a rayon worker,
1601    // which writes the row's values into `None`-filled columns. It needs the
1602    // rows and the column values to be `Send`; that is its conditional `where`
1603    // clause, so a row shape without it is not an error: `from_rows_par` falls
1604    // back to `from_rows` (`from_rows_par_override`).
1605    let has_par_impl = !columns.is_empty() || !auto_expand_cols.is_empty() || has_tag;
1606    let (parallel_columns_item, from_rows_par_method) = if has_par_impl {
1607        let mut par_bounds: Vec<(TokenStream, TokenStream)> = ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [({
                        let mut _s = ::quote::__private::TokenStream::new();
                        ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                        ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                        _s
                    },
                    {
                        let mut _s = ::quote::__private::TokenStream::new();
                        ::quote::__private::push_colon2(&mut _s);
                        ::quote::__private::push_ident(&mut _s, "core");
                        ::quote::__private::push_colon2(&mut _s);
                        ::quote::__private::push_ident(&mut _s, "marker");
                        ::quote::__private::push_colon2(&mut _s);
                        ::quote::__private::push_ident(&mut _s, "Send");
                        _s
                    })]))vec![(
1608            quote! { #row_name #ty_generics },
1609            quote! { ::core::marker::Send },
1610        )];
1611        for col in &columns {
1612            let ty = &col.ty;
1613            par_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "marker");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Send");
    _s
}quote! { ::core::marker::Send }));
1614        }
1615        for ac in &auto_expand_cols {
1616            let cty = &ac.container_ty;
1617            par_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&cty, &mut _s);
    _s
}quote! { #cty }, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "marker");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Send");
    _s
}quote! { ::core::marker::Send }));
1618        }
1619
1620        // Column declarations
1621        let mut par_col_decls = Vec::new();
1622        if has_tag {
1623            par_col_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "String");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1624                let mut __mx_col__tag: ::std::vec::Vec<::std::string::String> = ::std::vec![::std::string::String::new(); __mx_len];
1625            });
1626        }
1627        let nones = |name: &syn::Ident, ty: &syn::Type| {
1628            let local = column_local(name);
1629            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Iterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "take");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "iter");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "repeat_with");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_or_or(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "None");
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__mx_len");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1630                let mut #local: ::std::vec::Vec<::core::option::Option<#ty>> =
1631                    ::core::iter::Iterator::collect(::core::iter::Iterator::take(
1632                        ::core::iter::repeat_with(|| ::core::option::Option::None),
1633                        __mx_len,
1634                    ));
1635            }
1636        };
1637        for col in &columns {
1638            par_col_decls.push(nones(&col.col_name, &col.ty));
1639        }
1640        for ac in &auto_expand_cols {
1641            par_col_decls.push(nones(&ac.df_field, &ac.container_ty));
1642        }
1643
1644        // Writer declarations
1645        let mut writer_decls = Vec::new();
1646        if has_tag {
1647            writer_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__w_tag");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon_bridge");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnWriter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1648                let __w_tag = unsafe {
1649                    ::miniextendr_api::rayon_bridge::ColumnWriter::new(&mut __mx_col__tag)
1650                };
1651            });
1652        }
1653        for col in &columns {
1654            let name = &col.col_name;
1655            let local = column_local(name);
1656            let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(name)) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(name));
1657            writer_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon_bridge");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnWriter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::ToTokens::to_tokens(&local, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1658                let #w_name = unsafe {
1659                    ::miniextendr_api::rayon_bridge::ColumnWriter::new(&mut #local)
1660                };
1661            });
1662        }
1663        for ac in &auto_expand_cols {
1664            let name = &ac.df_field;
1665            let local = column_local(name);
1666            let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(name)) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(name));
1667            writer_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon_bridge");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnWriter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::ToTokens::to_tokens(&local, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1668                let #w_name = unsafe {
1669                    ::miniextendr_api::rayon_bridge::ColumnWriter::new(&mut #local)
1670                };
1671            });
1672        }
1673
1674        // Match arms for parallel path
1675        let par_match_arms: Vec<TokenStream> = variant_infos
1676            .iter()
1677            .enumerate()
1678            .map(|(variant_idx, vi)| {
1679                let variant_name = &vi.name;
1680                let variant_name_str = variant_name.to_string();
1681
1682                let tag_write = if has_tag {
1683                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__w_tag");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { __w_tag.write(__i, #variant_name_str.to_string()); }
1684                } else {
1685                    TokenStream::new()
1686                };
1687
1688                // Write calls for schema columns
1689                let col_writes: Vec<TokenStream> = columns
1690                    .iter()
1691                    .map(|col| {
1692                        let col_name = &col.col_name;
1693                        let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(col_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(col_name));
1694                        if col.present_in.contains(&variant_idx) {
1695                            let col_name_str = col_name.to_string();
1696                            for (pos, erf) in vi.fields.iter().enumerate() {
1697                                match erf {
1698                                    EnumResolvedField::Single(data)
1699                                        if data.col_name == *col_name =>
1700                                    {
1701                                        let binding = &data.binding;
1702                                        if col.string_coerced {
1703                                            return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "string");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "ToString");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::ToTokens::to_tokens(&binding, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::Some(::std::string::ToString::to_string(&#binding))); };
1704                                        } else {
1705                                            return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&binding, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::Some(#binding)); };
1706                                        }
1707                                    }
1708                                    EnumResolvedField::ExpandedFixed(data) => {
1709                                        let elems = enum_elem_idents(pos, data.len);
1710                                        for (i, elem) in elems.iter().enumerate() {
1711                                            let expanded_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i + 1))
    })format!("{}_{}", data.base_name, i + 1);
1712                                            if expanded_name == col_name_str {
1713                                                return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&elem, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::Some(#elem)); };
1714                                            }
1715                                        }
1716                                    }
1717                                    EnumResolvedField::ExpandedVec(data) => {
1718                                        let elems = enum_elem_idents(pos, data.width);
1719                                        for (i, elem) in elems.iter().enumerate() {
1720                                            let expanded_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i + 1))
    })format!("{}_{}", data.base_name, i + 1);
1721                                            if expanded_name == col_name_str {
1722                                                return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, #elem); };
1723                                            }
1724                                        }
1725                                    }
1726                                    EnumResolvedField::Map(data) => {
1727                                        let keys_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
1728                                        let vals_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
1729                                        let binding = &data.binding;
1730                                        // Combined unzip: emit both key and value writes when the
1731                                        // keys column is processed; skip the values column (handled here).
1732                                        if col_name_str == keys_name {
1733                                            let vals_col = match ::quote::__private::IdentFragmentAdapter(&vals_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}", vals_name);
1734                                            let w_vals = match ::quote::__private::IdentFragmentAdapter(&vals_col) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", vals_col);
1735                                            return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unzip");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__mx_keys");
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&w_vals, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__mx_vals");
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1736                                                let (__mx_keys, __mx_vals) = #binding.into_iter().unzip::<_, _, ::std::vec::Vec<_>, ::std::vec::Vec<_>>();
1737                                                #w_name.write(__i, ::core::option::Option::Some(__mx_keys));
1738                                                #w_vals.write(__i, ::core::option::Option::Some(__mx_vals));
1739                                            };
1740                                        }
1741                                        if col_name_str == vals_name {
1742                                            // Already handled when keys col was processed.
1743                                            return ::quote::__private::TokenStream::new()quote! {};
1744                                        }
1745                                    }
1746                                    // Struct field: write Some(binding) to Vec<Option<Inner>>.
1747                                    EnumResolvedField::Struct(data)
1748                                        if data.base_name == col_name_str =>
1749                                    {
1750                                        let binding = &data.binding;
1751                                        return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&binding, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::Some(#binding)); };
1752                                    }
1753                                    _ => {}
1754                                }
1755                            }
1756                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::None); }
1757                        } else {
1758                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::None); }
1759                        }
1760                    })
1761                    .collect();
1762
1763                let elem_prelude = expanded_elem_prelude(vi, false);
1764
1765                // Auto-expand write calls
1766                let auto_expand_writes: Vec<TokenStream> = auto_expand_cols
1767                    .iter()
1768                    .map(|ac| {
1769                        let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&ac.df_field))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(&ac.df_field));
1770                        if ac.present_in.contains(&variant_idx) {
1771                            for erf in &vi.fields {
1772                                if let EnumResolvedField::AutoExpandVec(data) = erf
1773                                    && data.base_name == ac.base_name
1774                                {
1775                                    let binding = &data.binding;
1776                                    return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&binding, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::Some(#binding)); };
1777                                }
1778                            }
1779                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::None); }
1780                        } else {
1781                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "None");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, ::core::option::Option::None); }
1782                        }
1783                    })
1784                    .collect();
1785
1786                // Generate destructure pattern based on variant shape
1787                match vi.shape {
1788                    VariantShape::Named => {
1789                        let mut field_bindings: Vec<TokenStream> = vi.fields.iter().map(|erf| {
1790                            let rust_name = erf.rust_name();
1791                            let binding = erf.binding();
1792                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #rust_name: #binding }
1793                        }).collect();
1794                        for skipped in &vi.skipped_fields {
1795                            field_bindings.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&skipped, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    _s
}quote! { #skipped: _ });
1796                        }
1797                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut field_bindings, i) =
                    field_bindings.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let field_bindings =
                        match field_bindings.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&field_bindings, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_write, &mut _s);
            ::quote::ToTokens::to_tokens(&elem_prelude, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut col_writes, i) = col_writes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let col_writes =
                        match col_writes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&col_writes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut auto_expand_writes, i) =
                    auto_expand_writes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let auto_expand_writes =
                        match auto_expand_writes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&auto_expand_writes, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
1798                            #row_name::#variant_name { #(#field_bindings),* } => {
1799                                #tag_write
1800                                #elem_prelude
1801                                #(#col_writes)*
1802                                #(#auto_expand_writes)*
1803                            }
1804                        }
1805                    }
1806                    VariantShape::Tuple => {
1807                        let field_bindings: Vec<TokenStream> = vi.fields.iter().map(|erf| {
1808                            let binding = erf.binding();
1809                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding }
1810                        }).collect();
1811                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut field_bindings, i) =
                    field_bindings.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let field_bindings =
                        match field_bindings.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&field_bindings, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_write, &mut _s);
            ::quote::ToTokens::to_tokens(&elem_prelude, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut col_writes, i) = col_writes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let col_writes =
                        match col_writes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&col_writes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut auto_expand_writes, i) =
                    auto_expand_writes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let auto_expand_writes =
                        match auto_expand_writes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&auto_expand_writes, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
1812                            #row_name::#variant_name(#(#field_bindings),*) => {
1813                                #tag_write
1814                                #elem_prelude
1815                                #(#col_writes)*
1816                                #(#auto_expand_writes)*
1817                            }
1818                        }
1819                    }
1820                    VariantShape::Unit => {
1821                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_write, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut col_writes, i) = col_writes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let col_writes =
                        match col_writes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&col_writes, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut auto_expand_writes, i) =
                    auto_expand_writes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let auto_expand_writes =
                        match auto_expand_writes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&auto_expand_writes, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
1822                            #row_name::#variant_name => {
1823                                #tag_write
1824                                #(#col_writes)*
1825                                #(#auto_expand_writes)*
1826                            }
1827                        }
1828                    }
1829                }
1830            })
1831            .collect();
1832
1833        // Return struct fields
1834        let par_tag_field = if has_tag {
1835            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { _tag: __mx_col__tag, }
1836        } else {
1837            TokenStream::new()
1838        };
1839        let mut par_struct_fields: Vec<TokenStream> = columns
1840            .iter()
1841            .map(|col| {
1842                let name = &col.col_name;
1843                let local = column_local(name);
1844                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local }
1845            })
1846            .collect();
1847        for ac in &auto_expand_cols {
1848            let name = &ac.df_field;
1849            let local = column_local(name);
1850            par_struct_fields.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local });
1851        }
1852
1853        let parallel_columns_item = parallel_columns_impl(
1854            df_name,
1855            row_name,
1856            &input.generics,
1857            &par_bounds,
1858            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "use");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rayon_bridge");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rayon");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "prelude");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_star(&mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "optionals");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "parallel");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ensure_pool");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__mx_len");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rows");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut par_col_decls, i) = par_col_decls.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let par_col_decls =
                match par_col_decls.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&par_col_decls, &mut _s);
        }
    }
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut writer_decls, i) = writer_decls.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let writer_decls =
                        match writer_decls.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&writer_decls, &mut _s);
                }
            }
            ::quote::__private::push_ident(&mut _s, "rows");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_par_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "enumerate");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for_each");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__i");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__row");
                            _s
                        });
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "unsafe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "match");
                            ::quote::__private::push_ident(&mut _s, "__row");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    {
                                        use ::quote::__private::ext::*;
                                        let has_iter = ::quote::__private::HasIterator::<false>;
                                        #[allow(unused_mut)]
                                        let (mut par_match_arms, i) =
                                            par_match_arms.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let par_match_arms =
                                                match par_match_arms.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            ::quote::ToTokens::to_tokens(&par_match_arms, &mut _s);
                                        }
                                    }
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&par_tag_field, &mut _s);
            ::quote::ToTokens::to_tokens(&phantom_init, &mut _s);
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut par_struct_fields, i) =
                    par_struct_fields.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let par_struct_fields =
                        match par_struct_fields.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&par_struct_fields, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
1859                use ::miniextendr_api::rayon_bridge::rayon::prelude::*;
1860                ::miniextendr_api::optionals::parallel::ensure_pool();
1861                let __mx_len = rows.len();
1862                #(#par_col_decls)*
1863                {
1864                    #(#writer_decls)*
1865                    rows.into_par_iter().enumerate().for_each(|(__i, __row)| unsafe {
1866                        match __row {
1867                            #(#par_match_arms)*
1868                        }
1869                    });
1870                }
1871                #df_name { #par_tag_field #phantom_init #(#par_struct_fields),* }
1872            },
1873        );
1874        (
1875            parallel_columns_item,
1876            from_rows_par_override({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    _s
}quote! { #row_name #ty_generics }),
1877        )
1878    } else {
1879        (TokenStream::new(), TokenStream::new())
1880    };
1881    // endregion
1882
1883    // region: ColumnarFrame impl on the enum companion (from_rows / from_rows_par)
1884    //
1885    // The pure-Rust columnar verbs live on the `ColumnarFrame` trait. `into_rows` (the
1886    // provided, `IntoIterator`-bounded default) is not callable on enum companions — they
1887    // have no `IntoIterator` and are read back across the R boundary via `FromDataFrame` /
1888    // the one-call `try_from_dataframe`.
1889    let df_methods = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ColumnarFrame");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from_rows");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::ToTokens::to_tokens(&from_rows_par_method, &mut _s);
            _s
        });
    _s
}quote! {
1890        impl #impl_generics ::miniextendr_api::dataframe::ColumnarFrame<#row_name #ty_generics>
1891            for #df_name #ty_generics #where_clause
1892        {
1893            fn from_rows(rows: ::std::vec::Vec<#row_name #ty_generics>) -> Self {
1894                rows.into()
1895            }
1896
1897            #from_rows_par_method
1898        }
1899    };
1900    // endregion
1901
1902    // region: enum reader (#807) — computed here so `row_methods` can embed the methods
1903    //
1904    // Build the enum reader methods (if this enum is reader-capable). Must happen before
1905    // `row_methods` since `row_methods` embeds the reader methods inline.
1906    let enum_reader_early = build_enum_reader(
1907        row_name,
1908        &variant_infos,
1909        &columns,
1910        attrs,
1911        &impl_generics,
1912        &ty_generics,
1913        where_clause,
1914    );
1915    // endregion
1916
1917    // region: Generate associated methods
1918    let enum_reader_methods = enum_reader_early.clone().unwrap_or_default();
1919    // The documented rows→companion verb is `ColumnarFrame::from_rows` / `Vec<Row>: Into`.
1920    // `to_dataframe` is retained `#[doc(hidden)]` because the struct-flatten / nested-enum
1921    // write paths build a nested companion via `Inner::to_dataframe(..)` without naming the
1922    // inner companion type. The enum readers ride here too (when reader-capable).
1923    let row_methods = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "hidden");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "pub");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "to_dataframe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::ToTokens::to_tokens(&df_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::ToTokens::to_tokens(&enum_reader_methods, &mut _s);
            _s
        });
    _s
}quote! {
1924        impl #impl_generics #row_name #ty_generics #where_clause {
1925            #[doc(hidden)]
1926            pub fn to_dataframe(rows: ::std::vec::Vec<Self>) -> #df_name #ty_generics {
1927                rows.into()
1928            }
1929
1930            #enum_reader_methods
1931        }
1932    };
1933
1934    // region: Generate the split representation (hidden to_dataframe_split + DataFrameRowSplit)
1935    let split_method = generate_split_method(
1936        row_name,
1937        &variant_infos,
1938        &impl_generics,
1939        &ty_generics,
1940        where_clause,
1941    );
1942    // endregion
1943
1944    // Marker trait impl: row type implements DataFrameRow via IntoDataFrame chain.
1945    // This is the impl the compile-time assertion checks for struct-typed variant fields.
1946    let marker_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "markers");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameRow");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        ::quote::__private::TokenStream::new());
    _s
}quote! {
1947        impl #impl_generics ::miniextendr_api::markers::DataFrameRow
1948            for #row_name #ty_generics #where_clause {}
1949    };
1950
1951    // DataFramePayloadFields impl (#486): exposes FIELDS (all resolved column names,
1952    // deduplicated) and TAG for compile-time collision detection by outer enums.
1953    // FIELDS lists every single-column payload field name across all variants.
1954    // TAG is the inner enum's #[dataframe(tag = "...")] value (or "" if absent).
1955    let payload_fields_impl = {
1956        // Collect unique field names from all variant payload fields (single columns only).
1957        // We skip expanded (fixed/vec) and struct fields — only direct column contributions.
1958        let mut field_names: Vec<String> = Vec::new();
1959        let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
1960        for vi in &variant_infos {
1961            for erf in &vi.fields {
1962                if let EnumResolvedField::Single(data) = erf {
1963                    let name = data.col_name.to_string();
1964                    if seen.insert(name.clone()) {
1965                        field_names.push(name);
1966                    }
1967                }
1968            }
1969        }
1970        let tag_str = attrs.tag.as_deref().unwrap_or("");
1971        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "markers");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFramePayloadFields");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_ident(&mut _s, "FIELDS");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_lifetime(&mut _s, "\'static");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_lifetime(&mut _s, "\'static");
                    ::quote::__private::push_ident(&mut _s, "str");
                    _s
                });
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut field_names, i) = field_names.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let field_names =
                                match field_names.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&field_names, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_ident(&mut _s, "TAG");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_lifetime(&mut _s, "\'static");
            ::quote::__private::push_ident(&mut _s, "str");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&tag_str, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
1972            impl #impl_generics ::miniextendr_api::markers::DataFramePayloadFields
1973                for #row_name #ty_generics #where_clause
1974            {
1975                const FIELDS: &'static [&'static str] = &[#(#field_names),*];
1976                const TAG: &'static str = #tag_str;
1977            }
1978        }
1979    };
1980
1981    // region: unit-only enum factor impls
1982    // For a unit-only enum (all variants are unit), auto-emit:
1983    //   1. `impl UnitEnumFactor for Self`  — provides FACTOR_LEVELS and to_factor_index()
1984    //   2. `impl IntoR for Self`  — produces a single-element factor SEXP (cached levels)
1985    //   3. `impl IntoList for Self`  — delegates to vec![self].into_list()
1986    //
1987    // The `UnitEnumFactor` impl is consumed by the blanket
1988    // `impl<T: UnitEnumFactor> IntoR for FactorOptionVec<T>` in miniextendr-api,
1989    // which is what `into_data_frame` calls for `as_factor` companion struct columns.
1990    //
1991    // NOTE: `impl IntoR for Vec<Option<Self>>` violates orphan rules (Vec is foreign),
1992    // so we use the `FactorOptionVec<T>` wrapper type (local to miniextendr-api) instead.
1993    //
1994    // These impls allow `as_factor` and `as_list` to work on the inner type when it
1995    // appears as a field of an outer enum or struct DataFrameRow.
1996    let unit_only_factor_impls = {
1997        let all_unit = variant_infos
1998            .iter()
1999            .all(|vi| vi.shape == VariantShape::Unit);
2000        // For unit-only enums, auto-emit three impls:
2001        //   1. `impl UnitEnumFactor for Self`  — provides FACTOR_LEVELS and to_factor_index()
2002        //   2. `impl IntoR for Self`  — produces a single-element factor SEXP
2003        //   3. `impl IntoList for Self`  — delegates to vec![self].into_list()
2004        //
2005        // Non-generic enums: `IntoR` caches the levels SEXP via `OnceLock<SEXP>` (one-time
2006        // `R_PreserveObject`).
2007        //
2008        // Generic enums: Rust does not allow generic statics, so `IntoR` builds the levels
2009        // SEXP on each call through `build_factor_with_levels`, which keeps the levels
2010        // rooted while it builds the factor. `impl<T: UnitEnumFactor> IntoR for
2011        // FactorOptionVec<T>` in `miniextendr-api/src/factor.rs` makes the same call.
2012        if all_unit {
2013            // Collect variant names and assign 1-based R factor indices (used by both branches).
2014            let variant_idents: Vec<&syn::Ident> =
2015                variant_infos.iter().map(|vi| &vi.name).collect();
2016            let variant_strs: Vec<String> =
2017                variant_infos.iter().map(|vi| vi.name.to_string()).collect();
2018            let variant_strs_lit: Vec<&str> = variant_strs.iter().map(|s| s.as_str()).collect();
2019            let indices: Vec<i32> = (1i32..=(variant_idents.len() as i32)).collect();
2020
2021            if impl_generics.to_token_stream().is_empty() {
2022                // Non-generic: cache levels SEXP permanently via OnceLock (one R_PreserveObject).
2023                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "factor");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "UnitEnumFactor");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_ident(&mut _s, "FACTOR_LEVELS");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_lifetime(&mut _s, "\'static");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_lifetime(&mut _s, "\'static");
                    ::quote::__private::push_ident(&mut _s, "str");
                    _s
                });
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut variant_strs_lit, i) =
                            variant_strs_lit.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let variant_strs_lit =
                                match variant_strs_lit.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&variant_strs_lit, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "to_factor_index");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "i32");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut row_name, i) = row_name.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut variant_idents, i) =
                                    variant_idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut indices, i) = indices.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let row_name =
                                        match row_name.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let variant_idents =
                                        match variant_idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let indices =
                                        match indices.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::ToTokens::to_tokens(&variant_idents, &mut _s);
                                    ::quote::__private::push_fat_arrow(&mut _s);
                                    ::quote::ToTokens::to_tokens(&indices, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                }
                            }
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from_factor_index");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "idx");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "i32");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "idx");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut indices, i) = indices.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut row_name, i) = row_name.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut variant_idents, i) =
                                    variant_idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let indices =
                                        match indices.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let row_name =
                                        match row_name.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let variant_idents =
                                        match variant_idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&indices, &mut _s);
                                    ::quote::__private::push_fat_arrow(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Some");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::ToTokens::to_tokens(&variant_idents, &mut _s);
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                }
                            }
                            ::quote::__private::push_underscore(&mut _s);
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "None");
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoR");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "type");
            ::quote::__private::push_ident(&mut _s, "Error");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Infallible");
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "try_into_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Infallible");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "use");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "sync");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "OnceLock");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "const");
                    ::quote::__private::push_ident(&mut _s, "LEVELS");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "str");
                            _s
                        });
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let mut _first = true;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut variant_strs_lit, i) =
                                    variant_strs_lit.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let variant_strs_lit =
                                        match variant_strs_lit.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    if !_first { ::quote::__private::push_comma(&mut _s); }
                                    _first = false;
                                    ::quote::ToTokens::to_tokens(&variant_strs_lit, &mut _s);
                                }
                            }
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "static");
                    ::quote::__private::push_ident(&mut _s, "LEVELS_CACHE");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "OnceLock");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "OnceLock");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "new");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "levels");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_star(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "LEVELS_CACHE");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "get_or_init");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_or_or(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "factor");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s,
                                        "build_levels_sexp_cached");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "LEVELS");
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "idx");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "i32");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut row_name, i) = row_name.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut variant_idents, i) =
                                    variant_idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut indices, i) = indices.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let row_name =
                                        match row_name.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let variant_idents =
                                        match variant_idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let indices =
                                        match indices.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::ToTokens::to_tokens(&variant_idents, &mut _s);
                                    ::quote::__private::push_fat_arrow(&mut _s);
                                    ::quote::ToTokens::to_tokens(&indices, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                }
                            }
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Ok");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "factor");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "build_factor");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_and(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Bracket,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "idx");
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "levels");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "list");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoList");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "into_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "list");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoList");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_list");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Bracket,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "self");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
2024                    // impl UnitEnumFactor for Self: provides FACTOR_LEVELS + to_factor_index().
2025                    // Used by `impl<T: UnitEnumFactor> IntoR for FactorOptionVec<T>` in miniextendr-api
2026                    // to build factor SEXPs from `Vec<Option<Self>>` companion columns.
2027                    impl ::miniextendr_api::factor::UnitEnumFactor for #row_name {
2028                        const FACTOR_LEVELS: &'static [&'static str] = &[#(#variant_strs_lit),*];
2029                        fn to_factor_index(self) -> i32 {
2030                            match self {
2031                                #(#row_name::#variant_idents => #indices,)*
2032                            }
2033                        }
2034                        fn from_factor_index(idx: i32) -> ::core::option::Option<Self> {
2035                            match idx {
2036                                #(#indices => ::core::option::Option::Some(#row_name::#variant_idents),)*
2037                                _ => ::core::option::Option::None,
2038                            }
2039                        }
2040                    }
2041
2042                    // impl IntoR for Self: single-element factor SEXP (cached levels via OnceLock).
2043                    // Used when a unit-only enum value is returned directly from a #[miniextendr] fn.
2044                    impl ::miniextendr_api::IntoR for #row_name {
2045                        type Error = ::std::convert::Infallible;
2046                        fn try_into_sexp(self) -> ::std::result::Result<::miniextendr_api::SEXP, ::std::convert::Infallible> {
2047                            use ::std::sync::OnceLock;
2048                            const LEVELS: &[&str] = &[#(#variant_strs_lit),*];
2049                            static LEVELS_CACHE: OnceLock<::miniextendr_api::SEXP> =
2050                                OnceLock::new();
2051                            let levels = *LEVELS_CACHE.get_or_init(|| {
2052                                ::miniextendr_api::factor::build_levels_sexp_cached(LEVELS)
2053                            });
2054                            let idx: i32 = match self {
2055                                #(#row_name::#variant_idents => #indices,)*
2056                            };
2057                            ::std::result::Result::Ok(
2058                                ::miniextendr_api::factor::build_factor(&[idx], levels)
2059                            )
2060                        }
2061                    }
2062
2063                    // impl IntoList for Self: for as_list path in outer DataFrameRow.
2064                    // Delegates to Vec<Self>: IntoList (blanket impl via IntoR for Self).
2065                    impl ::miniextendr_api::list::IntoList for #row_name {
2066                        fn into_list(self) -> ::miniextendr_api::list::List {
2067                            ::miniextendr_api::list::IntoList::into_list(::std::vec![self])
2068                        }
2069                    }
2070                }
2071            } else {
2072                // Generic: cannot use generic statics (Rust restriction).
2073                // Build the levels SEXP on each call and protect it across the build_factor
2074                // allocation — same pattern as `FactorOptionVec<T>: IntoR` in
2075                // `miniextendr-api/src/factor.rs`.
2076                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "factor");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "UnitEnumFactor");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_ident(&mut _s, "FACTOR_LEVELS");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_lifetime(&mut _s, "\'static");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_lifetime(&mut _s, "\'static");
                    ::quote::__private::push_ident(&mut _s, "str");
                    _s
                });
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut variant_strs_lit, i) =
                            variant_strs_lit.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let variant_strs_lit =
                                match variant_strs_lit.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&variant_strs_lit, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "to_factor_index");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "i32");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut row_name, i) = row_name.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut variant_idents, i) =
                                    variant_idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut indices, i) = indices.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let row_name =
                                        match row_name.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let variant_idents =
                                        match variant_idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let indices =
                                        match indices.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::ToTokens::to_tokens(&variant_idents, &mut _s);
                                    ::quote::__private::push_fat_arrow(&mut _s);
                                    ::quote::ToTokens::to_tokens(&indices, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                }
                            }
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from_factor_index");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "idx");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "i32");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "idx");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut indices, i) = indices.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut row_name, i) = row_name.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut variant_idents, i) =
                                    variant_idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let indices =
                                        match indices.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let row_name =
                                        match row_name.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let variant_idents =
                                        match variant_idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&indices, &mut _s);
                                    ::quote::__private::push_fat_arrow(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Some");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::ToTokens::to_tokens(&variant_idents, &mut _s);
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                }
                            }
                            ::quote::__private::push_underscore(&mut _s);
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "None");
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoR");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "type");
            ::quote::__private::push_ident(&mut _s, "Error");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Infallible");
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "try_into_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Infallible");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "const");
                    ::quote::__private::push_ident(&mut _s, "LEVELS");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "str");
                            _s
                        });
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let mut _first = true;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut variant_strs_lit, i) =
                                    variant_strs_lit.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let variant_strs_lit =
                                        match variant_strs_lit.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    if !_first { ::quote::__private::push_comma(&mut _s); }
                                    _first = false;
                                    ::quote::ToTokens::to_tokens(&variant_strs_lit, &mut _s);
                                }
                            }
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "idx");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "i32");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut row_name, i) = row_name.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut variant_idents, i) =
                                    variant_idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut indices, i) = indices.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let row_name =
                                        match row_name.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let variant_idents =
                                        match variant_idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let indices =
                                        match indices.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::ToTokens::to_tokens(&variant_idents, &mut _s);
                                    ::quote::__private::push_fat_arrow(&mut _s);
                                    ::quote::ToTokens::to_tokens(&indices, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                }
                            }
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Ok");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "factor");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s,
                                "build_factor_with_levels");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_and(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Bracket,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "idx");
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "LEVELS");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "list");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoList");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "into_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "list");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoList");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_list");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Bracket,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "self");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
2077                    // impl UnitEnumFactor: associated const is allowed in generic impls.
2078                    impl #impl_generics ::miniextendr_api::factor::UnitEnumFactor
2079                        for #row_name #ty_generics #where_clause
2080                    {
2081                        const FACTOR_LEVELS: &'static [&'static str] = &[#(#variant_strs_lit),*];
2082                        fn to_factor_index(self) -> i32 {
2083                            match self {
2084                                #(#row_name::#variant_idents => #indices,)*
2085                            }
2086                        }
2087                        fn from_factor_index(idx: i32) -> ::core::option::Option<Self> {
2088                            match idx {
2089                                #(#indices => ::core::option::Option::Some(#row_name::#variant_idents),)*
2090                                _ => ::core::option::Option::None,
2091                            }
2092                        }
2093                    }
2094
2095                    // impl IntoR: build levels SEXP on each call (no generic static allowed).
2096                    // build_factor_with_levels handles the PROTECT discipline internally —
2097                    // see CLAUDE.md "PROTECT discipline against R-devel GC".
2098                    impl #impl_generics ::miniextendr_api::IntoR
2099                        for #row_name #ty_generics #where_clause
2100                    {
2101                        type Error = ::std::convert::Infallible;
2102                        fn try_into_sexp(self) -> ::std::result::Result<::miniextendr_api::SEXP, ::std::convert::Infallible> {
2103                            const LEVELS: &[&str] = &[#(#variant_strs_lit),*];
2104                            let idx: i32 = match self {
2105                                #(#row_name::#variant_idents => #indices,)*
2106                            };
2107                            ::std::result::Result::Ok(
2108                                ::miniextendr_api::factor::build_factor_with_levels(&[idx], LEVELS)
2109                            )
2110                        }
2111                    }
2112
2113                    // impl IntoList: for as_list path in outer DataFrameRow.
2114                    impl #impl_generics ::miniextendr_api::list::IntoList
2115                        for #row_name #ty_generics #where_clause
2116                    {
2117                        fn into_list(self) -> ::miniextendr_api::list::List {
2118                            ::miniextendr_api::list::IntoList::into_list(::std::vec![self])
2119                        }
2120                    }
2121                }
2122            }
2123        } else {
2124            TokenStream::new()
2125        }
2126    };
2127    // endregion
2128
2129    // The enum reader was already computed above as `enum_reader_early`; alias it here
2130    // for the DataFrameRowConvert override logic.
2131    let enum_reader = enum_reader_early;
2132
2133    // region: DataFrameRowConvert on Row — orphan-rule bridge
2134    //
2135    // Same rationale as the struct path: `impl IntoDataFrame for Vec<Row>` is an orphan-rule
2136    // violation in the user crate, so the derive implements the local `DataFrameRowConvert`
2137    // marker on the local enum `Row`, and miniextendr_api's blanket provides the public
2138    // `Vec<Row>: IntoDataFrame`. Tagged enum shapes with reader-capable fields get a
2139    // `rows_from_dataframe` override; other shapes keep the trait default (`None`).
2140    // The build delegates to the companion engine via `ColumnSource::into_dataframe`;
2141    // the parallel path uses the #777 scatter-write builder when one was generated
2142    // for this shape, else the sequential transposition.
2143    let has_par_builder = !from_rows_par_method.is_empty();
2144    let rows_into_dataframe_par_body = if has_par_builder {
2145        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "convert");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ColumnSource");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&df_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnarFrame");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_rows_par");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    _s
}quote! {
2146            ::miniextendr_api::convert::ColumnSource::into_dataframe(
2147                <#df_name #ty_generics as ::miniextendr_api::dataframe::ColumnarFrame<
2148                    #row_name #ty_generics,
2149                >>::from_rows_par(rows),
2150            )
2151        }
2152    } else {
2153        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rows_into_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "rows");
            _s
        });
    _s
}quote! { Self::rows_into_dataframe(rows) }
2154    };
2155
2156    // rows_from_dataframe / rows_from_dataframe_par overrides (only when reader-capable).
2157    let reader_override = if let Some(ref reader_ts) = enum_reader {
2158        // Check whether the reader uses any Struct fields that would need Clone in par path.
2159        let has_struct_field_any = variant_infos.iter().any(|vi| {
2160            vi.fields
2161                .iter()
2162                .any(|f| #[allow(non_exhaustive_omitted_patterns)] match f {
    EnumResolvedField::Struct(_) => true,
    _ => false,
}matches!(f, EnumResolvedField::Struct(_)))
2163        });
2164        let par_reader_body = if has_struct_field_any {
2165            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "try_from_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__df");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "as_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    _s
}quote! { Self::try_from_dataframe(__df.as_sexp()) }
2166        } else {
2167            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "try_from_dataframe_par");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__df");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "as_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    _s
}quote! { Self::try_from_dataframe_par(__df.as_sexp()) }
2168        };
2169        let _ = reader_ts; // used below in row_methods
2170        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::__private::push_ident(&mut _s, "rows_from_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__df");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrame");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_rarrow(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameError");
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "try_from_dataframe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__df");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "as_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "map_err");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "dataframe");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "DataFrameError");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Conversion");
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__dataframe_row_when_rayon");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "rows_from_dataframe_par");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__df");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "DataFrame");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameError");
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Some");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&par_reader_body, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "map_err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "dataframe");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "DataFrameError");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Conversion");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
2171            fn rows_from_dataframe(
2172                __df: &::miniextendr_api::dataframe::DataFrame,
2173            ) -> ::core::option::Option<::core::result::Result<::std::vec::Vec<Self>, ::miniextendr_api::dataframe::DataFrameError>> {
2174                ::core::option::Option::Some(
2175                    <#row_name #ty_generics>::try_from_dataframe(__df.as_sexp())
2176                        .map_err(::miniextendr_api::dataframe::DataFrameError::Conversion)
2177                )
2178            }
2179
2180            ::miniextendr_api::__dataframe_row_when_rayon! {
2181                fn rows_from_dataframe_par(
2182                    __df: &::miniextendr_api::dataframe::DataFrame,
2183                ) -> ::core::option::Option<::core::result::Result<::std::vec::Vec<Self>, ::miniextendr_api::dataframe::DataFrameError>> {
2184                    ::core::option::Option::Some(
2185                        #par_reader_body
2186                            .map_err(::miniextendr_api::dataframe::DataFrameError::Conversion)
2187                    )
2188                }
2189            }
2190        }
2191    } else {
2192        TokenStream::new()
2193    };
2194
2195    let datarow_convert_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameRowConvert");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "rows_into_dataframe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrame");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameError");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "convert");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "ColumnSource");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_dataframe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "to_dataframe");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "rows");
                                    _s
                                });
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s,
                "__dataframe_row_when_rayon");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "fn");
                    ::quote::__private::push_ident(&mut _s,
                        "rows_into_dataframe_par");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "rows");
                            ::quote::__private::push_colon(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Self");
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    ::quote::__private::push_rarrow(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "DataFrame");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "DataFrameError");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&rows_into_dataframe_par_body,
                                &mut _s);
                            _s
                        });
                    _s
                });
            ::quote::ToTokens::to_tokens(&reader_override, &mut _s);
            _s
        });
    _s
}quote! {
2196        impl #impl_generics ::miniextendr_api::dataframe::DataFrameRowConvert
2197            for #row_name #ty_generics #where_clause
2198        {
2199            fn rows_into_dataframe(
2200                rows: ::std::vec::Vec<Self>,
2201            ) -> ::core::result::Result<
2202                ::miniextendr_api::dataframe::DataFrame,
2203                ::miniextendr_api::dataframe::DataFrameError,
2204            > {
2205                ::miniextendr_api::convert::ColumnSource::into_dataframe(
2206                    <#row_name #ty_generics>::to_dataframe(rows),
2207                )
2208            }
2209
2210            ::miniextendr_api::__dataframe_row_when_rayon! {
2211                fn rows_into_dataframe_par(
2212                    rows: ::std::vec::Vec<Self>,
2213                ) -> ::core::result::Result<
2214                    ::miniextendr_api::dataframe::DataFrame,
2215                    ::miniextendr_api::dataframe::DataFrameError,
2216                > {
2217                    #rows_into_dataframe_par_body
2218                }
2219            }
2220
2221            #reader_override
2222        }
2223    };
2224    // endregion
2225
2226    Ok({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&dataframe_struct, &mut _s);
    ::quote::ToTokens::to_tokens(&into_dataframe_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&from_vec_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&df_methods, &mut _s);
    ::quote::ToTokens::to_tokens(&parallel_columns_item, &mut _s);
    ::quote::ToTokens::to_tokens(&row_methods, &mut _s);
    ::quote::ToTokens::to_tokens(&split_method, &mut _s);
    ::quote::ToTokens::to_tokens(&marker_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&payload_fields_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&datarow_convert_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&borrow_impl, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut struct_assertions, i) = struct_assertions.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let struct_assertions =
                match struct_assertions.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&struct_assertions, &mut _s);
        }
    }
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut datetime_assertions, i) =
            datetime_assertions.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let datetime_assertions =
                match datetime_assertions.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&datetime_assertions, &mut _s);
        }
    }
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut payload_collision_assertions, i) =
            payload_collision_assertions.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let payload_collision_assertions =
                match payload_collision_assertions.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&payload_collision_assertions,
                &mut _s);
        }
    }
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut sibling_collision_assertions, i) =
            sibling_collision_assertions.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let sibling_collision_assertions =
                match sibling_collision_assertions.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&sibling_collision_assertions,
                &mut _s);
        }
    }
    ::quote::ToTokens::to_tokens(&unit_only_factor_impls, &mut _s);
    _s
}quote! {
2227        #dataframe_struct
2228        #into_dataframe_impl
2229        #from_vec_impl
2230        #df_methods
2231        #parallel_columns_item
2232        #row_methods
2233        #split_method
2234        #marker_impl
2235        #payload_fields_impl
2236        #datarow_convert_impl
2237        #borrow_impl
2238        #(#struct_assertions)*
2239        #(#datetime_assertions)*
2240        #(#payload_collision_assertions)*
2241        #(#sibling_collision_assertions)*
2242        #unit_only_factor_impls
2243    })
2244    // endregion
2245}
2246
2247// region: expanded field elements
2248
2249/// The variables an expanded field's elements are bound to, for the field at
2250/// `pos` in its variant: by position, since all of a variant's fields are bound
2251/// before any column is filled.
2252fn enum_elem_idents(pos: usize, n: usize) -> Vec<syn::Ident> {
2253    expanded_elem_idents(&::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("f{0}", pos))
    })format!("f{pos}"), n)
2254}
2255
2256/// Bind the elements of variant `vi`'s `[T; N]` / `width = N` fields to the
2257/// variables [`enum_elem_idents`] names, for a match arm whose pattern binds
2258/// each field to its `binding`. With `borrowed_rows` the arm matches a
2259/// borrowed row, so each binding is a reference and every element is cloned.
2260fn expanded_elem_prelude(vi: &VariantInfo, borrowed_rows: bool) -> TokenStream {
2261    let lets: Vec<TokenStream> = vi
2262        .fields
2263        .iter()
2264        .enumerate()
2265        .filter_map(|(pos, erf)| match erf {
2266            EnumResolvedField::ExpandedFixed(data) => {
2267                let binding = &data.binding;
2268                let elems = enum_elem_idents(pos, data.len);
2269                Some(fixed_array_elems(
2270                    &{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding },
2271                    data.borrowed || borrowed_rows,
2272                    &data.elem_ty,
2273                    &elems,
2274                ))
2275            }
2276            EnumResolvedField::ExpandedVec(data) => {
2277                let binding = &data.binding;
2278                let elems = enum_elem_idents(pos, data.width);
2279                let iter = match ::quote::__private::IdentFragmentAdapter(&pos) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mxv_f{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mxv_f{}", pos);
2280                // A borrowed row's binding may be a `&&[T]`, which is not
2281                // `IntoIterator`; its slice is, whatever the container.
2282                let access = if borrowed_rows {
2283                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&binding, &mut _s);
            _s
        });
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_dot2(&mut _s);
            _s
        });
    _s
}quote! { &(#binding)[..] }
2284                } else {
2285                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding }
2286                };
2287                Some(width_elems(
2288                    &access,
2289                    data.borrowed || borrowed_rows,
2290                    &data.elem_ty,
2291                    &iter,
2292                    &elems,
2293                ))
2294            }
2295            _ => None,
2296        })
2297        .collect();
2298    {
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut lets, i) = lets.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let lets =
                match lets.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&lets, &mut _s);
        }
    }
    _s
}quote! { #(#lets)* }
2299}
2300// endregion
2301
2302// region: generate_split_method
2303
2304/// Error for an `Option<scalar>` field inside an enum variant (#1437).
2305///
2306/// Enum variant fields are stored as `Vec<Option<T>>` (absent for the other
2307/// variants), so `Option<T>` here would need `Vec<Option<Option<T>>>`. Point
2308/// at the bare scalar rather than letting the missing conversion surface later.
2309fn option_scalar_in_variant_error(ty: &syn::Type) -> syn::Error {
2310    syn::Error::new_spanned(
2311        ty,
2312        "DataFrameRow enum variant fields already become `Option<T>` columns \
2313         (absent for the other variants), so `Option<scalar>` is not supported here. \
2314         Use the bare scalar (`f64`, `String`, …) and express absence by omitting the \
2315         field from the variant, or `#[dataframe(as_list)]` for an opaque list-column.",
2316    )
2317}
2318
2319/// Reject `u8` in every variant-field shape that reaches a column: a scalar or
2320/// `Option<u8>`, a fixed array, or a `width` / `expand` (`padded`) slice. Variant columns
2321/// are NA in rows of the other variants, and R raw vectors have no NA. A plain
2322/// `Vec<u8>` stays an opaque list-column and is accepted.
2323fn raw_variant_column_error(ty: &syn::Type, padded: bool) -> Option<syn::Error> {
2324    let raw = if option_payload(ty).is_some_and(is_raw_scalar_ty) {
2325        ty
2326    } else {
2327        match classify_field_type(ty).ok()? {
2328            FieldTypeKind::Scalar if is_raw_scalar_ty(ty) => ty,
2329            FieldTypeKind::FixedArray(elem, _) if is_raw_scalar_ty(elem) => elem,
2330            FieldTypeKind::VariableVec(elem)
2331            | FieldTypeKind::BoxedSlice(elem)
2332            | FieldTypeKind::BorrowedSlice(elem)
2333                if padded && is_raw_scalar_ty(elem) =>
2334            {
2335                elem
2336            }
2337            _ => return None,
2338        }
2339    };
2340    Some(raw_na_column_error(
2341        raw,
2342        "enum variant columns are NA in rows of the other variants",
2343        "Use `u16` or `i32` for an integer column; a plain `Vec<u8>` field stays a \
2344         list-column of raw vectors.",
2345    ))
2346}
2347
2348/// Generate the split representation for an enum `DataFrameRow`: the hidden
2349/// `to_dataframe_split` associated method (body holder) plus the
2350/// `DataFrameRowSplit` bridge impl that surfaces the public
2351/// `rows.into_dataframe_split()` verb (`IntoDataFrameSplit`).
2352///
2353/// Returns a `DataFrameShape` whose partitions are rooted `BuiltDataFrame`s
2354/// (#1750): `Bare` for a single-variant enum, `PerVariantList` (one entry per
2355/// variant, named with the snake_case variant name) otherwise. Each partition
2356/// data.frame has only that variant's columns (non-optional types — no NA fill
2357/// from other variants).
2358fn generate_split_method(
2359    row_name: &syn::Ident,
2360    variant_infos: &[VariantInfo],
2361    impl_generics: &syn::ImplGenerics<'_>,
2362    ty_generics: &syn::TypeGenerics<'_>,
2363    where_clause: Option<&syn::WhereClause>,
2364) -> TokenStream {
2365    // Per-variant buffer declarations
2366    let mut buf_decls: Vec<TokenStream> = Vec::new();
2367    // Per-variant match arms (push to buffers)
2368    let mut match_arms: Vec<TokenStream> = Vec::new();
2369    // Per-variant data.frame construction
2370    let mut df_constructions: Vec<TokenStream> = Vec::new();
2371    // Names of the constructed data.frame variables (for the outer list)
2372    let mut df_var_names: Vec<syn::Ident> = Vec::new();
2373    // Snake-case string names (for the outer list pairs)
2374    let mut snake_names: Vec<String> = Vec::new();
2375
2376    for vi in variant_infos {
2377        let variant_name = &vi.name;
2378        let snake = naming::to_snake_case(&variant_name.to_string());
2379        snake_names.push(snake.clone());
2380
2381        let df_var = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__{0}_df", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__{}_df", snake);
2382        df_var_names.push(df_var.clone());
2383
2384        // Determine if any field is AutoExpandVec or Struct (both require the dynamic pairs path
2385        // because column names are only known at runtime).
2386        let has_auto = vi.fields.iter().any(|f| {
2387            #[allow(non_exhaustive_omitted_patterns)] match f {
    EnumResolvedField::AutoExpandVec(_) | EnumResolvedField::Struct(_) =>
        true,
    _ => false,
}matches!(
2388                f,
2389                EnumResolvedField::AutoExpandVec(_) | EnumResolvedField::Struct(_)
2390            )
2391        });
2392
2393        match vi.shape {
2394            // region: Unit variant
2395            VariantShape::Unit => {
2396                let count_var = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__s_{0}_count", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__s_{}_count", snake);
2397                buf_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&count_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_ident(&mut _s, "usize");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::parse(&mut _s, "0usize");
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2398                    let mut #count_var: usize = 0usize;
2399                });
2400
2401                match_arms.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&count_var, &mut _s);
            ::quote::__private::push_add_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "1");
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
2402                    #row_name::#variant_name => {
2403                        #count_var += 1;
2404                    }
2405                });
2406
2407                df_constructions.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&df_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "list");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "List");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "from_raw_pairs_empty");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "set_class_str");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "\"data.frame\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "set_row_names_int");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&count_var, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2408                    let #df_var = ::miniextendr_api::list::List::from_raw_pairs_empty()
2409                    .set_class_str(&["data.frame"])
2410                    .set_row_names_int(#count_var);
2411                });
2412            }
2413            // endregion
2414
2415            // region: Named or Tuple variants
2416            VariantShape::Named | VariantShape::Tuple => {
2417                // Declare per-field buffers
2418                for erf in &vi.fields {
2419                    match erf {
2420                        EnumResolvedField::Single(data) => {
2421                            let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
            {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!(
2422                                "__s_{}_{}",
2423                                snake,
2424                                crate::naming::unraw(&data.col_name)
2425                            );
2426                            let ty = &data.ty;
2427                            // For needs_into_list fields this is the raw struct type; the
2428                            // list-column is built from it when the partition is assembled.
2429                            buf_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2430                                let mut #buf: ::std::vec::Vec<#ty> = ::std::vec::Vec::new();
2431                            });
2432                        }
2433                        EnumResolvedField::ExpandedFixed(data) => {
2434                            for i in 1..=data.len {
2435                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&i) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, i);
2436                                let elem_ty = &data.elem_ty;
2437                                buf_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2438                                    let mut #buf: ::std::vec::Vec<#elem_ty> = ::std::vec::Vec::new();
2439                                });
2440                            }
2441                        }
2442                        EnumResolvedField::ExpandedVec(data) => {
2443                            for i in 1..=data.width {
2444                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&i) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, i);
2445                                let elem_ty = &data.elem_ty;
2446                                buf_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2447                                    let mut #buf: ::std::vec::Vec<::core::option::Option<#elem_ty>> = ::std::vec::Vec::new();
2448                                });
2449                            }
2450                        }
2451                        EnumResolvedField::AutoExpandVec(data) => {
2452                            let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2453                            let container_ty = &data.container_ty;
2454                            buf_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&container_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2455                                let mut #buf: ::std::vec::Vec<#container_ty> = ::std::vec::Vec::new();
2456                            });
2457                        }
2458                        EnumResolvedField::Map(data) => {
2459                            let keys_buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_keys", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_keys", snake, data.base_name);
2460                            let vals_buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_values", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_values", snake, data.base_name);
2461                            let key_ty = &data.key_ty;
2462                            let val_ty = &data.val_ty;
2463                            buf_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&keys_buf, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&key_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&vals_buf, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&val_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2464                                let mut #keys_buf: ::std::vec::Vec<::std::vec::Vec<#key_ty>> = ::std::vec::Vec::new();
2465                                let mut #vals_buf: ::std::vec::Vec<::std::vec::Vec<#val_ty>> = ::std::vec::Vec::new();
2466                            });
2467                        }
2468                        // Struct field: buffer holds Vec<Inner> (no Option — split only sees
2469                        // rows of this variant, so every row has the field present).
2470                        EnumResolvedField::Struct(data) => {
2471                            let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2472                            let inner_ty = &data.inner_ty;
2473                            buf_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2474                                let mut #buf: ::std::vec::Vec<#inner_ty> = ::std::vec::Vec::new();
2475                            });
2476                        }
2477                    }
2478                }
2479
2480                // Build destructure pattern and push statements
2481                let push_stmts: Vec<TokenStream> = vi
2482                    .fields
2483                    .iter()
2484                    .enumerate()
2485                    .flat_map(|(pos, erf)| {
2486                        let binding = erf.binding();
2487                        match erf {
2488                            EnumResolvedField::Single(data) => {
2489                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
            {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, crate::naming::unraw(&data.col_name));
2490                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&binding, &mut _s);
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![quote! { #buf.push(#binding); }]
2491                            }
2492                            EnumResolvedField::ExpandedFixed(data) => {
2493                                let elems = enum_elem_idents(pos, data.len);
2494                                let mut stmts = ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [fixed_array_elems(&{
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&binding, &mut _s);
                            _s
                        }, data.borrowed, &data.elem_ty, &elems)]))vec![fixed_array_elems(
2495                                    &quote! { #binding },
2496                                    data.borrowed,
2497                                    &data.elem_ty,
2498                                    &elems,
2499                                )];
2500                                stmts.extend(elems.iter().enumerate().map(|(i, elem)| {
2501                                    let buf =
2502                                        match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, i + 1);
2503                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #buf.push(#elem); }
2504                                }));
2505                                stmts
2506                            }
2507                            EnumResolvedField::ExpandedVec(data) => {
2508                                let elems = enum_elem_idents(pos, data.width);
2509                                let iter = match ::quote::__private::IdentFragmentAdapter(&pos) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mxv_f{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mxv_f{}", pos);
2510                                let mut stmts = ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [width_elems(&{
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&binding, &mut _s);
                            _s
                        }, data.borrowed, &data.elem_ty, &iter, &elems)]))vec![width_elems(
2511                                    &quote! { #binding },
2512                                    data.borrowed,
2513                                    &data.elem_ty,
2514                                    &iter,
2515                                    &elems,
2516                                )];
2517                                stmts.extend(elems.iter().enumerate().map(|(i, elem)| {
2518                                    let buf =
2519                                        match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, i + 1);
2520                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #buf.push(#elem); }
2521                                }));
2522                                stmts
2523                            }
2524                            EnumResolvedField::AutoExpandVec(data) => {
2525                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2526                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&binding, &mut _s);
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![quote! { #buf.push(#binding); }]
2527                            }
2528                            EnumResolvedField::Map(data) => {
2529                                let keys_buf =
2530                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_keys", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_keys", snake, data.base_name);
2531                                let vals_buf =
2532                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_values", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_values", snake, data.base_name);
2533                                // unzip() guarantees pairwise alignment of keys and values.
2534                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__mx_keys");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__mx_vals");
                            _s
                        });
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::ToTokens::to_tokens(&binding, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_iter");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "unzip");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_underscore(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_underscore(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_underscore(&mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_underscore(&mut _s);
                    ::quote::__private::push_shr(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&keys_buf, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__mx_keys");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&vals_buf, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__mx_vals");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![quote! {
2535                                    let (__mx_keys, __mx_vals) = #binding.into_iter().unzip::<_, _, ::std::vec::Vec<_>, ::std::vec::Vec<_>>();
2536                                    #keys_buf.push(__mx_keys);
2537                                    #vals_buf.push(__mx_vals);
2538                                }]
2539                            }
2540                            // Struct field: push binding directly (split only sees this variant's rows,
2541                            // so every row has the field — no Option needed).
2542                            EnumResolvedField::Struct(data) => {
2543                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2544                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&binding, &mut _s);
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![quote! { #buf.push(#binding); }]
2545                            }
2546                        }
2547                    })
2548                    .collect();
2549
2550                let arm = match vi.shape {
2551                    VariantShape::Named => {
2552                        let mut field_bindings: Vec<TokenStream> = vi
2553                            .fields
2554                            .iter()
2555                            .map(|erf| {
2556                                let rust_name = erf.rust_name();
2557                                let binding = erf.binding();
2558                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #rust_name: #binding }
2559                            })
2560                            .collect();
2561                        for skipped in &vi.skipped_fields {
2562                            field_bindings.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&skipped, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    _s
}quote! { #skipped: _ });
2563                        }
2564                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut field_bindings, i) =
                    field_bindings.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let field_bindings =
                        match field_bindings.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&field_bindings, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut push_stmts, i) = push_stmts.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let push_stmts =
                        match push_stmts.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&push_stmts, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
2565                            #row_name::#variant_name { #(#field_bindings),* } => {
2566                                #(#push_stmts)*
2567                            }
2568                        }
2569                    }
2570                    VariantShape::Tuple => {
2571                        let bindings: Vec<TokenStream> = vi
2572                            .fields
2573                            .iter()
2574                            .map(|erf| {
2575                                let binding = erf.binding();
2576                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    _s
}quote! { #binding }
2577                            })
2578                            .collect();
2579                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut bindings, i) = bindings.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let bindings =
                        match bindings.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&bindings, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut push_stmts, i) = push_stmts.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let push_stmts =
                        match push_stmts.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&push_stmts, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
2580                            #row_name::#variant_name(#(#bindings),*) => {
2581                                #(#push_stmts)*
2582                            }
2583                        }
2584                    }
2585                    VariantShape::Unit => {
    ::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}",
            format_args!("handled above")));
}unreachable!("handled above"),
2586                };
2587                match_arms.push(arm);
2588
2589                // Construct the data.frame for this variant
2590                if has_auto {
2591                    // Dynamic path: build Vec<(String, SEXP)>
2592                    let pairs_var = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__pairs_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__pairs_{}", snake);
2593                    let n_var = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__n_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__n_{}", snake);
2594
2595                    // Find the first non-dynamic field for the length expression, or first dynamic.
2596                    // "Dynamic" = AutoExpandVec or Struct (both use dynamic pairs path).
2597                    let len_expr: TokenStream = {
2598                        let first_non_dynamic = vi.fields.iter().find(|f| {
2599                            !#[allow(non_exhaustive_omitted_patterns)] match f {
    EnumResolvedField::AutoExpandVec(_) | EnumResolvedField::Struct(_) =>
        true,
    _ => false,
}matches!(
2600                                f,
2601                                EnumResolvedField::AutoExpandVec(_) | EnumResolvedField::Struct(_)
2602                            )
2603                        });
2604                        if let Some(f) = first_non_dynamic {
2605                            match f {
2606                                EnumResolvedField::Single(data) => {
2607                                    let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
            {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!(
2608                                        "__s_{}_{}",
2609                                        snake,
2610                                        crate::naming::unraw(&data.col_name)
2611                                    );
2612                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2613                                }
2614                                EnumResolvedField::ExpandedFixed(data) => {
2615                                    let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&1usize) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!(
2616                                        "__s_{}_{}_{}",
2617                                        snake,
2618                                        data.base_name,
2619                                        1usize
2620                                    );
2621                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2622                                }
2623                                EnumResolvedField::ExpandedVec(data) => {
2624                                    let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&1usize) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!(
2625                                        "__s_{}_{}_{}",
2626                                        snake,
2627                                        data.base_name,
2628                                        1usize
2629                                    );
2630                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2631                                }
2632                                EnumResolvedField::AutoExpandVec(_)
2633                                | EnumResolvedField::Struct(_) => ::core::panicking::unreachable_default_msg()unreachable!(),
2634                                EnumResolvedField::Map(data) => {
2635                                    let keys_buf =
2636                                        match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_keys", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_keys", snake, data.base_name);
2637                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&keys_buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #keys_buf.len() }
2638                                }
2639                            }
2640                        } else {
2641                            // All fields are dynamic — use the first dynamic buf length
2642                            if let Some(first) = vi.fields.first() {
2643                                match first {
2644                                    EnumResolvedField::AutoExpandVec(data) => {
2645                                        let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2646                                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2647                                    }
2648                                    EnumResolvedField::Struct(data) => {
2649                                        let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2650                                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2651                                    }
2652                                    _ => {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::parse(&mut _s, "0usize");
    _s
}quote! { 0usize },
2653                                }
2654                            } else {
2655                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::parse(&mut _s, "0usize");
    _s
}quote! { 0usize }
2656                            }
2657                        }
2658                    };
2659
2660                    // Static pair pushes — wrap each `into_sexp()` in
2661                    // `__scope.protect_raw` to keep prior column SEXPs rooted
2662                    // across subsequent allocations
2663                    // (reviews/2026-05-07-gctorture-audit.md).
2664                    let static_pushes: Vec<TokenStream> = vi
2665                        .fields
2666                        .iter()
2667                        .flat_map(|erf| match erf {
2668                            EnumResolvedField::Single(data) => {
2669                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
            {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, crate::naming::unraw(&data.col_name));
2670                                let col_str = data.col_name.to_string();
2671                                let ty = &data.ty;
2672                                if data.needs_into_list {
2673                                    // Each cell's list goes straight into the rooted column.
2674                                    let into_list_column = list_column_fn(ty, false);
2675                                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "to_string");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&into_list_column, &mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![quote! {
2676                                        #pairs_var.push((
2677                                            #col_str.to_string(),
2678                                            __scope.protect_raw(#into_list_column(#buf)),
2679                                        ));
2680                                    }]
2681                                } else if data.is_factor {
2682                                    // Factor column: convert Vec<T> → FactorOptionVec<T> (all present).
2683                                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "to_string");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "IntoR");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "factor");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "FactorOptionVec");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_lt(&mut _s);
                                                    ::quote::ToTokens::to_tokens(&ty, &mut _s);
                                                    ::quote::__private::push_gt(&mut _s);
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "from");
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        {
                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                            ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                                            ::quote::__private::push_dot(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "into_iter");
                                                            ::quote::__private::push_group(&mut _s,
                                                                ::quote::__private::Delimiter::Parenthesis,
                                                                ::quote::__private::TokenStream::new());
                                                            ::quote::__private::push_dot(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "map");
                                                            ::quote::__private::push_group(&mut _s,
                                                                ::quote::__private::Delimiter::Parenthesis,
                                                                {
                                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                                    ::quote::__private::push_or(&mut _s);
                                                                    ::quote::__private::push_ident(&mut _s, "v");
                                                                    ::quote::__private::push_or(&mut _s);
                                                                    ::quote::__private::push_colon2(&mut _s);
                                                                    ::quote::__private::push_ident(&mut _s, "std");
                                                                    ::quote::__private::push_colon2(&mut _s);
                                                                    ::quote::__private::push_ident(&mut _s, "option");
                                                                    ::quote::__private::push_colon2(&mut _s);
                                                                    ::quote::__private::push_ident(&mut _s, "Option");
                                                                    ::quote::__private::push_colon2(&mut _s);
                                                                    ::quote::__private::push_ident(&mut _s, "Some");
                                                                    ::quote::__private::push_group(&mut _s,
                                                                        ::quote::__private::Delimiter::Parenthesis,
                                                                        {
                                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                                            ::quote::__private::push_ident(&mut _s, "v");
                                                                            _s
                                                                        });
                                                                    _s
                                                                });
                                                            ::quote::__private::push_dot(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "collect");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_lt(&mut _s);
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "std");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "vec");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "Vec");
                                                            ::quote::__private::push_lt(&mut _s);
                                                            ::quote::__private::push_underscore(&mut _s);
                                                            ::quote::__private::push_shr(&mut _s);
                                                            ::quote::__private::push_group(&mut _s,
                                                                ::quote::__private::Delimiter::Parenthesis,
                                                                ::quote::__private::TokenStream::new());
                                                            _s
                                                        });
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![quote! {
2684                                        #pairs_var.push((
2685                                            #col_str.to_string(),
2686                                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(
2687                                                ::miniextendr_api::factor::FactorOptionVec::<#ty>::from(
2688                                                    #buf.into_iter().map(|v| ::std::option::Option::Some(v)).collect::<::std::vec::Vec<_>>()
2689                                                )
2690                                            )),
2691                                        ));
2692                                    }]
2693                                } else {
2694                                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "to_string");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "IntoR");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![quote! {
2695                                        #pairs_var.push((
2696                                            #col_str.to_string(),
2697                                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#buf)),
2698                                        ));
2699                                    }]
2700                                }
2701                            }
2702                            EnumResolvedField::ExpandedFixed(data) => (1..=data.len)
2703                                .map(|i| {
2704                                    let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&i) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!(
2705                                        "__s_{}_{}_{}", snake, data.base_name, i
2706                                    );
2707                                    let col_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
2708                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2709                                        #pairs_var.push((
2710                                            #col_str.to_string(),
2711                                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#buf)),
2712                                        ));
2713                                    }
2714                                })
2715                                .collect(),
2716                            EnumResolvedField::ExpandedVec(data) => (1..=data.width)
2717                                .map(|i| {
2718                                    let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&i) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!(
2719                                        "__s_{}_{}_{}", snake, data.base_name, i
2720                                    );
2721                                    let col_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
2722                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2723                                        #pairs_var.push((
2724                                            #col_str.to_string(),
2725                                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#buf)),
2726                                        ));
2727                                    }
2728                                })
2729                                .collect(),
2730                            EnumResolvedField::AutoExpandVec(data) => {
2731                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2732                                let base_str = &data.base_name;
2733                                let elem_ty = &data.elem_ty;
2734                                let elems_iter =
2735                                    owned_elems_iter(&{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row_vec");
    _s
}quote! { __row_vec }, data.borrowed, elem_ty);
2736                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__auto");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::ToTokens::to_tokens(&buf, &mut _s);
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__max");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__auto");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "iter");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "map");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_or(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "v");
                                    ::quote::__private::push_or(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "v");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "len");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "max");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "unwrap_or");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s, "0");
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "mut");
                            ::quote::__private::push_ident(&mut _s, "__auto_cols");
                            ::quote::__private::push_colon(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                            ::quote::__private::push_shr(&mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s, "0");
                                    ::quote::__private::push_dot2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__max");
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "map");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_or(&mut _s);
                                    ::quote::__private::push_underscore(&mut _s);
                                    ::quote::__private::push_or(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "with_capacity");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&n_var, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "collect");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "for");
                            ::quote::__private::push_ident(&mut _s, "__row_vec");
                            ::quote::__private::push_ident(&mut _s, "in");
                            ::quote::__private::push_ident(&mut _s, "__auto");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "let");
                                    ::quote::__private::push_ident(&mut _s, "mut");
                                    ::quote::__private::push_ident(&mut _s, "__elems");
                                    ::quote::__private::push_eq(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elems_iter, &mut _s);
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "for");
                                    ::quote::__private::push_ident(&mut _s, "__acol");
                                    ::quote::__private::push_ident(&mut _s, "in");
                                    ::quote::__private::push_ident(&mut _s, "__auto_cols");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "iter_mut");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Brace,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__acol");
                                            ::quote::__private::push_dot(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "push");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "core");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "iter");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "Iterator");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "next");
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        {
                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                            ::quote::__private::push_and(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "mut");
                                                            ::quote::__private::push_ident(&mut _s, "__elems");
                                                            _s
                                                        });
                                                    _s
                                                });
                                            ::quote::__private::push_semi(&mut _s);
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_ident(&mut _s, "for");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__ai");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__acol");
                                    _s
                                });
                            ::quote::__private::push_ident(&mut _s, "in");
                            ::quote::__private::push_ident(&mut _s, "__auto_cols");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_iter");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "enumerate");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "std");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "format");
                                                    ::quote::__private::push_bang(&mut _s);
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        {
                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::ToTokens::to_tokens(&base_str, &mut _s);
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "__ai");
                                                            ::quote::__private::push_add(&mut _s);
                                                            ::quote::__private::parse(&mut _s, "1");
                                                            _s
                                                        });
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                                    ::quote::__private::push_dot(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        {
                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "IntoR");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                                                            ::quote::__private::push_group(&mut _s,
                                                                ::quote::__private::Delimiter::Parenthesis,
                                                                {
                                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                                    ::quote::__private::push_ident(&mut _s, "__acol");
                                                                    _s
                                                                });
                                                            _s
                                                        });
                                                    ::quote::__private::push_comma(&mut _s);
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                }]))vec![quote! {
2737                                    {
2738                                        let __auto = #buf;
2739                                        let __max = __auto.iter().map(|v| v.len()).max().unwrap_or(0);
2740                                        let mut __auto_cols: ::std::vec::Vec<::std::vec::Vec<::core::option::Option<#elem_ty>>> = (0..__max)
2741                                            .map(|_| ::std::vec::Vec::with_capacity(#n_var))
2742                                            .collect();
2743                                        for __row_vec in __auto {
2744                                            let mut __elems = #elems_iter;
2745                                            for __acol in __auto_cols.iter_mut() {
2746                                                __acol.push(::core::iter::Iterator::next(&mut __elems));
2747                                            }
2748                                        }
2749                                        for (__ai, __acol) in __auto_cols.into_iter().enumerate() {
2750                                            #pairs_var.push((
2751                                                ::std::format!("{}_{}", #base_str, __ai + 1),
2752                                                __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(__acol)),
2753                                            ));
2754                                        }
2755                                    }
2756                                }]
2757                            }
2758                            EnumResolvedField::Map(data) => {
2759                                let keys_buf =
2760                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_keys", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_keys", snake, data.base_name);
2761                                let vals_buf =
2762                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_values", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_values", snake, data.base_name);
2763                                let keys_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
2764                                let vals_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
2765                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&keys_str, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "to_string");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "IntoR");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::ToTokens::to_tokens(&keys_buf, &mut _s);
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                },
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&vals_str, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "to_string");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "IntoR");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::ToTokens::to_tokens(&vals_buf, &mut _s);
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                }]))vec![
2766                                    quote! {
2767                                        #pairs_var.push((
2768                                            #keys_str.to_string(),
2769                                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#keys_buf)),
2770                                        ));
2771                                    },
2772                                    quote! {
2773                                        #pairs_var.push((
2774                                            #vals_str.to_string(),
2775                                            __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#vals_buf)),
2776                                        ));
2777                                    },
2778                                ]
2779                            }
2780                            // Struct field: call Inner::to_dataframe(buf), extract columns,
2781                            // push with prefixed names. In the split path, all rows belong to
2782                            // this variant so no scatter is needed.
2783                            EnumResolvedField::Struct(data) => {
2784                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, data.base_name);
2785                                let base_str = &data.base_name;
2786                                let inner_ty = &data.inner_ty;
2787                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__inner_df");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "to_dataframe");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__inner_cols");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "convert");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "ColumnSource");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s,
                                "into_named_columns");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__inner_df");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_and(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "for");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__inner_col_name");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__inner_col_sexp");
                                    _s
                                });
                            ::quote::__private::push_ident(&mut _s, "in");
                            ::quote::__private::push_ident(&mut _s, "__inner_cols");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "let");
                                    ::quote::__private::push_ident(&mut _s, "__prefixed");
                                    ::quote::__private::push_eq(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&base_str, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__inner_col_name");
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_ident(&mut _s, "__prefixed");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__inner_col_sexp");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                }]))vec![quote! {
2788                                    {
2789                                        let __inner_df = <#inner_ty>::to_dataframe(#buf);
2790                                        // The inner column list is rooted in __scope, which keeps
2791                                        // its columns alive until this partition owns them.
2792                                        let __inner_cols = ::miniextendr_api::convert::ColumnSource::into_named_columns(
2793                                            __inner_df,
2794                                            &__scope,
2795                                        );
2796                                        for (__inner_col_name, __inner_col_sexp) in __inner_cols {
2797                                            let __prefixed = ::std::format!("{}_{}", #base_str, __inner_col_name);
2798                                            #pairs_var.push((__prefixed, __inner_col_sexp));
2799                                        }
2800                                    }
2801                                }]
2802                            }
2803                        })
2804                        .collect();
2805
2806                    df_constructions.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&n_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&len_expr, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&df_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "gc_protect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ProtectScope");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "string");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "String");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    _s
                });
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut static_pushes, i) = static_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let static_pushes =
                        match static_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&static_pushes, &mut _s);
                }
            }
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_raw_pairs");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&pairs_var, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_class_str");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"data.frame\"");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_row_names_int");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&n_var, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2807                        let #n_var = #len_expr;
2808                        // SAFETY: split-method runs on the R main thread. The scope
2809                        // roots this partition's columns until `from_raw_pairs` owns
2810                        // them; the multi-variant body roots the finished partition.
2811                        let #df_var = unsafe {
2812                            let __scope = ::miniextendr_api::gc_protect::ProtectScope::new();
2813                            let mut #pairs_var: ::std::vec::Vec<(::std::string::String, ::miniextendr_api::SEXP)> = ::std::vec::Vec::new();
2814                            #(#static_pushes)*
2815                            ::miniextendr_api::list::List::from_raw_pairs(#pairs_var)
2816                                .set_class_str(&["data.frame"])
2817                                .set_row_names_int(#n_var)
2818                        };
2819                    });
2820                } else {
2821                    // Static path: vec![...] of (&str, SEXP) pairs
2822                    let n_var = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__n_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__n_{}", snake);
2823
2824                    // Length expression: first field's buffer length
2825                    let len_expr: TokenStream = if let Some(erf) = vi.fields.first() {
2826                        match erf {
2827                            EnumResolvedField::Single(data) => {
2828                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
            {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!(
2829                                    "__s_{}_{}",
2830                                    snake,
2831                                    crate::naming::unraw(&data.col_name)
2832                                );
2833                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2834                            }
2835                            EnumResolvedField::ExpandedFixed(data) => {
2836                                let buf =
2837                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&1usize) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, 1usize);
2838                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2839                            }
2840                            EnumResolvedField::ExpandedVec(data) => {
2841                                let buf =
2842                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&1usize) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, 1usize);
2843                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #buf.len() }
2844                            }
2845                            // AutoExpandVec and Struct both trigger has_auto = true, so these
2846                            // branches are unreachable in the non-auto static path.
2847                            EnumResolvedField::AutoExpandVec(_) | EnumResolvedField::Struct(_) => {
2848                                ::core::panicking::unreachable_default_msg()unreachable!()
2849                            }
2850                            EnumResolvedField::Map(data) => {
2851                                let keys_buf =
2852                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_keys", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_keys", snake, data.base_name);
2853                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&keys_buf, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #keys_buf.len() }
2854                            }
2855                        }
2856                    } else {
2857                        // No fields (unexpected for Named/Tuple, but handle it)
2858                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::parse(&mut _s, "0usize");
    _s
}quote! { 0usize }
2859                    };
2860
2861                    // Collect pairs — each `into_sexp()` is rooted via
2862                    // `__scope.protect_raw` so prior columns survive the
2863                    // next column's allocation
2864                    // (reviews/2026-05-07-gctorture-audit.md).
2865                    let pairs: Vec<TokenStream> = vi
2866                        .fields
2867                        .iter()
2868                        .flat_map(|erf| match erf {
2869                            EnumResolvedField::Single(data) => {
2870                                let buf = match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
            {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}", snake, crate::naming::unraw(&data.col_name));
2871                                let col_str = data.col_name.to_string();
2872                                let ty = &data.ty;
2873                                if data.needs_into_list {
2874                                    // Convert Vec<T> → list-column at split time; each cell's
2875                                    // list goes straight into the rooted column.
2876                                    let into_list_column = list_column_fn(ty, false);
2877                                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__scope");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "protect_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&into_list_column, &mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    _s
                }]))vec![quote! {
2878                                        (#col_str, __scope.protect_raw(#into_list_column(#buf)))
2879                                    }]
2880                                } else if data.is_factor {
2881                                    // Factor: convert Vec<T> → FactorOptionVec<T> (all present).
2882                                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__scope");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "protect_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "IntoR");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "factor");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "FactorOptionVec");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_lt(&mut _s);
                                            ::quote::ToTokens::to_tokens(&ty, &mut _s);
                                            ::quote::__private::push_gt(&mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "from");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                                    ::quote::__private::push_dot(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "into_iter");
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        ::quote::__private::TokenStream::new());
                                                    ::quote::__private::push_dot(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "map");
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        {
                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                            ::quote::__private::push_or(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "v");
                                                            ::quote::__private::push_or(&mut _s);
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "std");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "option");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "Option");
                                                            ::quote::__private::push_colon2(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "Some");
                                                            ::quote::__private::push_group(&mut _s,
                                                                ::quote::__private::Delimiter::Parenthesis,
                                                                {
                                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                                    ::quote::__private::push_ident(&mut _s, "v");
                                                                    _s
                                                                });
                                                            _s
                                                        });
                                                    ::quote::__private::push_dot(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "collect");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_lt(&mut _s);
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "std");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "vec");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                                    ::quote::__private::push_lt(&mut _s);
                                                    ::quote::__private::push_underscore(&mut _s);
                                                    ::quote::__private::push_shr(&mut _s);
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        ::quote::__private::TokenStream::new());
                                                    _s
                                                });
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    _s
                }]))vec![quote! {
2883                                        (#col_str, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(
2884                                            ::miniextendr_api::factor::FactorOptionVec::<#ty>::from(
2885                                                #buf.into_iter().map(|v| ::std::option::Option::Some(v)).collect::<::std::vec::Vec<_>>()
2886                                            )
2887                                        )))
2888                                    }]
2889                                } else {
2890                                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&col_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__scope");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "protect_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "IntoR");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&buf, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    _s
                }]))vec![quote! {
2891                                        (#col_str, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#buf)))
2892                                    }]
2893                                }
2894                            }
2895                            EnumResolvedField::ExpandedFixed(data) => (1..=data.len)
2896                                .map(|i| {
2897                                    let buf =
2898                                        match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&i) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, i);
2899                                    let col_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
2900                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&col_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "protect_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoR");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&buf, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
2901                                        (#col_str, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#buf)))
2902                                    }
2903                                })
2904                                .collect(),
2905                            EnumResolvedField::ExpandedVec(data) => (1..=data.width)
2906                                .map(|i| {
2907                                    let buf =
2908                                        match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                match ::quote::__private::IdentFragmentAdapter(&i) {
                    arg =>
                        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                        ::alloc::fmt::format(format_args!("__s_{0}_{1}_{2}", arg,
                                                arg, arg))
                                    }),
                            ::quote::__private::Option::None.or(arg.span()).or(arg.span()).or(arg.span())),
                },
        },
}format_ident!("__s_{}_{}_{}", snake, data.base_name, i);
2909                                    let col_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
2910                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&col_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "protect_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoR");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&buf, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
2911                                        (#col_str, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#buf)))
2912                                    }
2913                                })
2914                                .collect(),
2915                            // AutoExpandVec and Struct both trigger has_auto = true.
2916                            EnumResolvedField::AutoExpandVec(_) | EnumResolvedField::Struct(_) => ::core::panicking::unreachable_default_msg()unreachable!(),
2917                            EnumResolvedField::Map(data) => {
2918                                let keys_buf =
2919                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_keys", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_keys", snake, data.base_name);
2920                                let vals_buf =
2921                                    match ::quote::__private::IdentFragmentAdapter(&snake) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__s_{0}_{1}_values", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__s_{}_{}_values", snake, data.base_name);
2922                                let keys_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
2923                                let vals_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
2924                                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&keys_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__scope");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "protect_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "IntoR");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&keys_buf, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    _s
                },
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&vals_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__scope");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "protect_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "IntoR");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&vals_buf, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    _s
                }]))vec![
2925                                    quote! {
2926                                        (#keys_str, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#keys_buf)))
2927                                    },
2928                                    quote! {
2929                                        (#vals_str, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#vals_buf)))
2930                                    },
2931                                ]
2932                            }
2933                        })
2934                        .collect();
2935
2936                    df_constructions.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&n_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&len_expr, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&df_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "gc_protect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ProtectScope");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_raw_pairs");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let mut _first = true;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut pairs, i) = pairs.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let pairs =
                                        match pairs.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    if !_first { ::quote::__private::push_comma(&mut _s); }
                                    _first = false;
                                    ::quote::ToTokens::to_tokens(&pairs, &mut _s);
                                }
                            }
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_class_str");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"data.frame\"");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_row_names_int");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&n_var, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2937                        let #n_var = #len_expr;
2938                        // SAFETY: see has_auto branch.
2939                        let #df_var = unsafe {
2940                            let __scope = ::miniextendr_api::gc_protect::ProtectScope::new();
2941                            ::miniextendr_api::list::List::from_raw_pairs(::std::vec![
2942                                #(#pairs),*
2943                            ])
2944                            .set_class_str(&["data.frame"])
2945                            .set_row_names_int(#n_var)
2946                        };
2947                    });
2948                }
2949            } // endregion
2950        }
2951    }
2952
2953    // Root every partition as an owned `BuiltDataFrame` the moment it is built:
2954    // later partitions allocate, and an unrooted earlier one would be reaped
2955    // before the result owns it (#1748). The handles also keep the partitions
2956    // rooted after `to_dataframe_split` returns, so the caller may hold the
2957    // result across allocations before converting it (#1750). Nothing allocates
2958    // between a partition's construction (its own `ProtectScope` has closed)
2959    // and `adopt_sexp`'s `R_PreserveObject`.
2960    let rooted_constructions: Vec<TokenStream> = df_constructions
2961        .iter()
2962        .zip(df_var_names.iter())
2963        .map(|(construction, var)| {
2964            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&construction, &mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "BuiltDataFrame");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "adopt_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoR");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&var, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2965                #construction
2966                // SAFETY: R main thread; `#var` is a freshly built data.frame
2967                // and nothing allocates before it is rooted.
2968                let #var = unsafe {
2969                    ::miniextendr_api::dataframe::BuiltDataFrame::adopt_sexp(
2970                        ::miniextendr_api::IntoR::into_sexp(#var),
2971                    )
2972                };
2973            }
2974        })
2975        .collect();
2976
2977    let shape = if variant_infos.len() == 1 {
2978        // Single variant: the data.frame itself.
2979        let df_var = &df_var_names[0];
2980        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameShape");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Bare");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&df_var, &mut _s);
            _s
        });
    _s
}quote! {
2981            ::miniextendr_api::dataframe::DataFrameShape::Bare(#df_var)
2982        }
2983    } else {
2984        // Multiple variants: one named partition per declared variant.
2985        let outer_pairs: Vec<TokenStream> = snake_names
2986            .iter()
2987            .zip(df_var_names.iter())
2988            .map(|(name, var)| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "String");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&name, &mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&var, &mut _s);
            _s
        });
    _s
}quote! { (::std::string::String::from(#name), #var) })
2989            .collect();
2990        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameShape");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "PerVariantList");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut outer_pairs, i) = outer_pairs.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let outer_pairs =
                                match outer_pairs.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&outer_pairs, &mut _s);
                        }
                    }
                    _s
                });
            _s
        });
    _s
}quote! {
2991            ::miniextendr_api::dataframe::DataFrameShape::PerVariantList(::std::vec![
2992                #(#outer_pairs),*
2993            ])
2994        }
2995    };
2996
2997    let body = {
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut buf_decls, i) = buf_decls.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let buf_decls =
                match buf_decls.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&buf_decls, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_ident(&mut _s, "in");
    ::quote::__private::push_ident(&mut _s, "rows");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "match");
            ::quote::__private::push_ident(&mut _s, "__row");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut match_arms, i) = match_arms.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let match_arms =
                                match match_arms.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::ToTokens::to_tokens(&match_arms, &mut _s);
                        }
                    }
                    _s
                });
            _s
        });
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut rooted_constructions, i) =
            rooted_constructions.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let rooted_constructions =
                match rooted_constructions.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&rooted_constructions, &mut _s);
        }
    }
    ::quote::ToTokens::to_tokens(&shape, &mut _s);
    _s
}quote! {
2998        #(#buf_decls)*
2999        for __row in rows {
3000            match __row {
3001                #(#match_arms)*
3002            }
3003        }
3004        #(#rooted_constructions)*
3005        #shape
3006    };
3007
3008    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "hidden");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "pub");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "to_dataframe_split");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameShape");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&body, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameRowSplit");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "rows_into_dataframe_split");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameShape");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "to_dataframe_split");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "rows");
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
3009        impl #impl_generics #row_name #ty_generics #where_clause {
3010            // The documented split verb is `IntoDataFrameSplit::into_dataframe_split`
3011            // (via the `DataFrameRowSplit` bridge below); this inherent holds the
3012            // body and stays `pub` off the documented surface, mirroring the hidden
3013            // `to_dataframe(rows)` companion helper.
3014            #[doc(hidden)]
3015            pub fn to_dataframe_split(
3016                rows: ::std::vec::Vec<Self>,
3017            ) -> ::miniextendr_api::dataframe::DataFrameShape {
3018                #body
3019            }
3020        }
3021
3022        // Orphan-rule bridge: `impl IntoDataFrameSplit for Vec<Row>` is illegal here
3023        // (`Row` is covered by `Vec<_>`), so implement the local-type bridge trait and
3024        // let `miniextendr_api`'s blanket impl surface `rows.into_dataframe_split()`.
3025        impl #impl_generics ::miniextendr_api::dataframe::DataFrameRowSplit
3026            for #row_name #ty_generics #where_clause
3027        {
3028            fn rows_into_dataframe_split(
3029                rows: ::std::vec::Vec<Self>,
3030            ) -> ::miniextendr_api::dataframe::DataFrameShape {
3031                Self::to_dataframe_split(rows)
3032            }
3033        }
3034    }
3035}
3036// endregion
3037
3038// region: enum reader (#807)
3039
3040/// Check whether an enum field is reader-capable.
3041///
3042/// Mirrors `field_reader_capable` from `dataframe_derive.rs` but for `EnumResolvedField`.
3043/// Key differences vs the struct path:
3044/// - `Single` enum fields are always `Vec<Option<ty>>` (even non-factor) because the
3045///   writer wraps every cell in `Option`; so we only need `is_reader_scalar_ty`
3046///   (which accepts both bare scalars and `Option<scalar>`).
3047/// - `is_factor` Single fields are reader-capable iff the inner type satisfies
3048///   `UnitEnumFactor` — guaranteed by the derive for unit-only enums.
3049/// - `Map` fields are reader-capable iff both `K` and `V` are bare scalar element
3050///   types: the reader regroups the `<base>_keys` / `<base>_values` list-columns
3051///   (each row a `Vec<K>` / `Vec<V>`) back into the map via `Vec<elem>: TryFromSexp`.
3052///   `Option`-wrapped key/value element types are excluded (the writer emits them,
3053///   but the reader path is restricted to the round-trippable bare-scalar set).
3054fn enum_field_reader_capable(erf: &EnumResolvedField) -> bool {
3055    match erf {
3056        EnumResolvedField::Single(data) => {
3057            !data.needs_into_list
3058                && (data.is_factor || is_reader_scalar_ty(&data.ty) || is_datetime_ty(&data.ty))
3059        }
3060        EnumResolvedField::ExpandedFixed(data) => {
3061            !data.borrowed && is_reader_scalar_ty(&data.elem_ty)
3062        }
3063        EnumResolvedField::ExpandedVec(data) => {
3064            !data.borrowed && is_bare_reader_scalar_ty(&data.elem_ty)
3065        }
3066        EnumResolvedField::AutoExpandVec(data) => {
3067            !data.borrowed && is_bare_reader_scalar_ty(&data.elem_ty)
3068        }
3069        EnumResolvedField::Map(data) => {
3070            is_bare_reader_scalar_ty(&data.key_ty) && is_bare_reader_scalar_ty(&data.val_ty)
3071        }
3072        EnumResolvedField::Struct(_) => true, // routes through inner DataFrameRowConvert
3073    }
3074}
3075
3076/// The value of field `erf` in row `__i` of variant `variant_name_str`, read
3077/// from the reader's extracted columns. With `take`, each cell is moved out of
3078/// its column: the sequential reader owns the columns and visits each row once.
3079/// Without it, the cell is cloned: the parallel reader shares the columns
3080/// across threads, and reads only scalar columns, which are all `Clone`.
3081fn enum_reader_field_value(
3082    erf: &EnumResolvedField,
3083    variant_name_str: &str,
3084    take: bool,
3085) -> TokenStream {
3086    let cell = |col_var: &syn::Ident| {
3087        if take {
3088            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "take");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    _s
}quote! { ::core::option::Option::take(&mut #col_var[__i]) }
3089        } else {
3090            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    _s
}quote! { ::core::clone::Clone::clone(&#col_var[__i]) }
3091        }
3092    };
3093    let required = |col_var: &syn::Ident, what: &str, col_name_str: &str| {
3094        let cell = cell(col_var);
3095        let msg = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("variant `{{}}` row {{}}: {0} `{{}}` is NA but field is required",
                what))
    })format!("variant `{{}}` row {{}}: {what} `{{}}` is NA but field is required");
3096        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&cell, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ok_or_else");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or_or(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "format");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&msg, &mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__i");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_question(&mut _s);
    _s
}quote! {
3097            #cell.ok_or_else(|| ::std::format!(#msg, #variant_name_str, __i, #col_name_str))?
3098        }
3099    };
3100    match erf {
3101        EnumResolvedField::Single(data) => {
3102            let col_var = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__col_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__col_{}", crate::naming::unraw(&data.col_name));
3103            let what = if data.is_factor {
3104                "factor column"
3105            } else {
3106                "column"
3107            };
3108            required(&col_var, what, &data.col_name.to_string())
3109        }
3110        EnumResolvedField::ExpandedFixed(data) => {
3111            let elem_ty = &data.elem_ty;
3112            let len = data.len;
3113            let slots: Vec<TokenStream> = (1..=data.len)
3114                .map(|k| {
3115                    let col_var = match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&k) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__col_{0}_{1}", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__col_{}_{}", data.base_name, k);
3116                    required(&col_var, "column", &::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, k))
    })format!("{}_{}", data.base_name, k))
3117                })
3118                .collect();
3119            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__arr");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&len, &mut _s);
                    _s
                });
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut slots, i) = slots.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let slots =
                                match slots.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&slots, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__arr");
            _s
        });
    _s
}quote! { { let __arr: [#elem_ty; #len] = [ #(#slots),* ]; __arr } }
3120        }
3121        EnumResolvedField::ExpandedVec(data) => {
3122            let elem_ty = &data.elem_ty;
3123            let slots: Vec<TokenStream> = (1..=data.width)
3124                .map(|k| cell(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&k) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__col_{0}_{1}", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__col_{}_{}", data.base_name, k)))
3125                .collect();
3126            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut slots, i) = slots.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let slots =
                        match slots.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&slots, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "flatten");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { [ #(#slots),* ].into_iter().flatten().collect::<::std::vec::Vec<#elem_ty>>().into() }
3127        }
3128        EnumResolvedField::AutoExpandVec(data) => {
3129            let elem_ty = &data.elem_ty;
3130            let cols_var = match ::quote::__private::IdentFragmentAdapter(&data.base_name.replace('-',
                "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__aev_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__aev_{}", data.base_name.replace('-', "_"));
3131            let cells = if take {
3132                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "filter_map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&cols_var, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter_mut");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__c");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "take");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "mut");
                            ::quote::__private::push_ident(&mut _s, "__c");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Bracket,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__i");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
3133                    ::core::iter::Iterator::filter_map(#cols_var.iter_mut(), |__c| {
3134                        ::core::option::Option::take(&mut __c[__i])
3135                    })
3136                }
3137            } else {
3138                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "filter_map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&cols_var, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__c");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__c");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Bracket,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__i");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
3139                    ::core::iter::Iterator::filter_map(#cols_var.iter(), |__c| {
3140                        ::core::clone::Clone::clone(&__c[__i])
3141                    })
3142                }
3143            };
3144            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&cells, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #cells.collect::<::std::vec::Vec<#elem_ty>>().into() }
3145        }
3146        EnumResolvedField::Map(data) => {
3147            let keys_var = match ::quote::__private::IdentFragmentAdapter(&data.base_name.replace('-',
                "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_{}_keys", data.base_name.replace('-', "_"));
3148            let vals_var = match ::quote::__private::IdentFragmentAdapter(&data.base_name.replace('-',
                "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_{0}_values",
                                arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_{}_values", data.base_name.replace('-', "_"));
3149            let base = &data.base_name;
3150            let map_ty = &data.map_ty;
3151            let keys = required(&keys_var, "map column", base);
3152            let vals = required(&vals_var, "map column", base);
3153            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__keys");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&keys, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__vals");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&vals, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "if");
            ::quote::__private::push_ident(&mut _s, "__keys");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_ne(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__vals");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "return");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Err");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"variant `{}` row {}: map column `{}` has {} keys but {} values\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__i");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&base, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__keys");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "len");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__vals");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "len");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "__keys");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "zip");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__vals");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "collect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&map_ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    _s
}quote! {
3154                {
3155                    let __keys = #keys;
3156                    let __vals = #vals;
3157                    if __keys.len() != __vals.len() {
3158                        return ::core::result::Result::Err(::std::format!(
3159                            "variant `{}` row {}: map column `{}` has {} keys but {} values",
3160                            #variant_name_str, __i, #base, __keys.len(), __vals.len()
3161                        ));
3162                    }
3163                    __keys.into_iter().zip(__vals).collect::<#map_ty>()
3164                }
3165            }
3166        }
3167        EnumResolvedField::Struct(data) => {
3168            let vec_var = match ::quote::__private::IdentFragmentAdapter(&data.base_name.replace('-',
                "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__sf_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__sf_{}", data.base_name.replace('-', "_"));
3169            let base = &data.base_name;
3170            let cell = cell(&vec_var);
3171            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&cell, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ok_or_else");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or_or(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "format");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"variant `{}` row {}: struct field `{}` is absent for this variant\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__i");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::ToTokens::to_tokens(&base, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_question(&mut _s);
    _s
}quote! {
3172                #cell.ok_or_else(|| ::std::format!(
3173                    "variant `{}` row {}: struct field `{}` is absent for this variant",
3174                    #variant_name_str, __i, #base
3175                ))?
3176            }
3177        }
3178    }
3179}
3180
3181/// Build the `try_from_dataframe` / `try_from_dataframe_par` methods for a tagged enum.
3182///
3183/// Returns `None` if the enum is not reader-capable (tagless, has skipped fields,
3184/// has `conflicts = "string"`, or has a field type that can't be read back from R).
3185/// When `None`, the enum keeps the `DataFrameRowConvert` trait default (`rows_from_dataframe
3186/// → None`), which surfaces as a clear `DataFrameError::Conversion` at runtime.
3187#[allow(clippy::too_many_arguments)]
3188fn build_enum_reader(
3189    row_name: &syn::Ident,
3190    variant_infos: &[VariantInfo],
3191    columns: &[ResolvedColumn],
3192    attrs: &DataFrameAttrs,
3193    _impl_generics: &syn::ImplGenerics<'_>,
3194    _ty_generics: &syn::TypeGenerics<'_>,
3195    _where_clause: Option<&syn::WhereClause>,
3196) -> Option<TokenStream> {
3197    // Gate 1: must have a tag column.
3198    let tag_col_name = attrs.tag.as_deref()?;
3199
3200    // Gate 2: no skipped fields.
3201    if variant_infos.iter().any(|vi| !vi.skipped_fields.is_empty()) {
3202        return None;
3203    }
3204
3205    // Gate 3: no string coercion.
3206    if attrs.conflicts.is_some() {
3207        return None;
3208    }
3209
3210    // Gate 4: every field across all variants must be reader-capable.
3211    if !variant_infos
3212        .iter()
3213        .all(|vi| vi.fields.iter().all(enum_field_reader_capable))
3214    {
3215        return None;
3216    }
3217
3218    // Struct-flatten and factor columns hold user types, which need not be
3219    // `Clone`: the parallel reader, which clones cells, delegates to the
3220    // sequential one, which moves them, for these shapes.
3221    let par_delegates = variant_infos.iter().any(|vi| {
3222        vi.fields.iter().any(|f| {
3223            #[allow(non_exhaustive_omitted_patterns)] match f {
    EnumResolvedField::Struct(_) => true,
    _ => false,
}matches!(f, EnumResolvedField::Struct(_))
3224                || #[allow(non_exhaustive_omitted_patterns)] match f {
    EnumResolvedField::Single(d) if d.is_factor => true,
    _ => false,
}matches!(f, EnumResolvedField::Single(d) if d.is_factor)
3225        })
3226    });
3227
3228    // Auto-expand columns are discovered at runtime in the generated code — no prelude needed.
3229
3230    // region: column extraction prelude (R-thread, all SEXP access up front)
3231    // Pull each schema column as Vec<Option<elem>> (every enum column is Option-wrapped
3232    // because absent variants push None).
3233    let mut extracts: Vec<TokenStream> = Vec::new();
3234
3235    // Tag column: pull as Vec<String>.
3236    let tag_var = ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("__tag"))
            }), ::quote::__private::Option::None)format_ident!("__tag");
3237    extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&tag_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__tag_sexp");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "column_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&tag_col_name, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ok_or_else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"tag column `{}` is missing from the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&tag_col_name, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "String");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_r");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "TryFromSexp");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "try_from_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__tag_sexp");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map_err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "e");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"tag column `{}` could not be read as strings: {}\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&tag_col_name, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "e");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&tag_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"tag column `{}` has length {} but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&tag_col_name, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&tag_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3238        let #tag_var: ::std::vec::Vec<::std::string::String> = {
3239            let __tag_sexp = __view.column_raw(#tag_col_name).ok_or_else(|| {
3240                ::std::format!("tag column `{}` is missing from the data.frame", #tag_col_name)
3241            })?;
3242            <::std::vec::Vec<::std::string::String> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__tag_sexp)
3243                .map_err(|e| ::std::format!(
3244                    "tag column `{}` could not be read as strings: {}",
3245                    #tag_col_name, e
3246                ))?
3247        };
3248        if #tag_var.len() != __nrow {
3249            return ::core::result::Result::Err(::std::format!(
3250                "tag column `{}` has length {} but data.frame has {} rows",
3251                #tag_col_name, #tag_var.len(), __nrow
3252            ));
3253        }
3254    });
3255
3256    // For each static schema column, pull as Vec<Option<ty>>.
3257    // Collect which column names are Struct fields to handle densify separately.
3258    let mut struct_col_names: std::collections::HashSet<String> = std::collections::HashSet::new();
3259    for vi in variant_infos {
3260        for erf in &vi.fields {
3261            if let EnumResolvedField::Struct(data) = erf {
3262                struct_col_names.insert(data.base_name.clone());
3263            }
3264        }
3265    }
3266
3267    // Collect Map column names (`<base>_keys` / `<base>_values`). These are registered
3268    // in `columns` as `Vec<K>` / `Vec<V>` but have no `Vec<Option<Vec<_>>>: TryFromSexp`
3269    // impl, so the generic loop below skips them; bespoke list-column extraction follows.
3270    let mut map_col_names: std::collections::HashSet<String> = std::collections::HashSet::new();
3271    for vi in variant_infos {
3272        for erf in &vi.fields {
3273            if let EnumResolvedField::Map(data) = erf {
3274                map_col_names.insert(::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name));
3275                map_col_names.insert(::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name));
3276            }
3277        }
3278    }
3279
3280    for col in columns {
3281        let col_name_str = col.col_name.to_string();
3282        let col_var = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&col.col_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__col_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__col_{}", crate::naming::unraw(&col.col_name));
3283        let ty = &col.ty;
3284
3285        // Skip Struct columns — they are handled separately via sub-frame densify.
3286        if struct_col_names.contains(&col_name_str) {
3287            continue;
3288        }
3289        // Skip Map columns — handled separately via the list-column regroup below.
3290        if map_col_names.contains(&col_name_str) {
3291            continue;
3292        }
3293
3294        if col.is_factor {
3295            // as_factor column: use unit_factor_option_vec_from_sexp.
3296            extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__col_sexp");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "column_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ok_or_else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"column `{}` is missing from the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "factor");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s,
                "unit_factor_option_vec_from_sexp");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map_err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "e");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"factor column `{}` could not be read: {}\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "e");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` has length {} but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3297                let mut #col_var: ::std::vec::Vec<::core::option::Option<#ty>> = {
3298                    let __col_sexp = __view.column_raw(#col_name_str).ok_or_else(|| {
3299                        ::std::format!("column `{}` is missing from the data.frame", #col_name_str)
3300                    })?;
3301                    ::miniextendr_api::factor::unit_factor_option_vec_from_sexp::<#ty>(__col_sexp)
3302                        .map_err(|e| ::std::format!(
3303                            "factor column `{}` could not be read: {}",
3304                            #col_name_str, e
3305                        ))?
3306                };
3307                if #col_var.len() != __nrow {
3308                    return ::core::result::Result::Err(::std::format!(
3309                        "column `{}` has length {} but data.frame has {} rows",
3310                        #col_name_str, #col_var.len(), __nrow
3311                    ));
3312                }
3313            });
3314        } else {
3315            // Regular column: pull as Vec<Option<ty>> via TryFromSexp.
3316            let opt_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "core");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "option");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Option");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::core::option::Option<#ty>);
3317            extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&opt_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__col_sexp");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "column_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ok_or_else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"column `{}` is missing from the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&opt_ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_r");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "TryFromSexp");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "try_from_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map_err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "e");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` could not be converted to the expected type: {}\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "e");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` has length {} but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3318                let mut #col_var: ::std::vec::Vec<#opt_ty> = {
3319                    let __col_sexp = __view.column_raw(#col_name_str).ok_or_else(|| {
3320                        ::std::format!("column `{}` is missing from the data.frame", #col_name_str)
3321                    })?;
3322                    <::std::vec::Vec<#opt_ty> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__col_sexp)
3323                        .map_err(|e| ::std::format!(
3324                            "column `{}` could not be converted to the expected type: {}",
3325                            #col_name_str, e
3326                        ))?
3327                };
3328                if #col_var.len() != __nrow {
3329                    return ::core::result::Result::Err(::std::format!(
3330                        "column `{}` has length {} but data.frame has {} rows",
3331                        #col_name_str, #col_var.len(), __nrow
3332                    ));
3333                }
3334            });
3335        }
3336    }
3337
3338    // For each auto-expand field, discover columns at runtime.
3339    // We collect the set of unique auto-expand base names across all variants.
3340    let mut auto_expand_base_names: Vec<(String, syn::Type)> = Vec::new();
3341    let mut seen_auto: std::collections::HashSet<String> = std::collections::HashSet::new();
3342    for vi in variant_infos {
3343        for erf in &vi.fields {
3344            if let EnumResolvedField::AutoExpandVec(data) = erf
3345                && seen_auto.insert(data.base_name.clone())
3346            {
3347                auto_expand_base_names.push((data.base_name.clone(), data.elem_ty.clone()));
3348            }
3349        }
3350    }
3351
3352    for (base_name, elem_ty) in &auto_expand_base_names {
3353        let cols_var = match ::quote::__private::IdentFragmentAdapter(&base_name.replace('-', "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__aev_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__aev_{}", base_name.replace('-', "_"));
3354        let opt_elem_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "core");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "option");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Option");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::core::option::Option<#elem_ty>);
3355        extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&cols_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&opt_elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__cols");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&opt_elem_ty, &mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__k");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "usize");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "1");
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "loop");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__cn");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&base_name, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__k");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "__view");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "column_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__cn");
                            _s
                        });
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Some");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__s");
                                    _s
                                });
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "let");
                                    ::quote::__private::push_ident(&mut _s, "__c");
                                    ::quote::__private::push_colon(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&opt_elem_ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_eq(&mut _s);
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&opt_elem_ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "as");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "from_r");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "TryFromSexp");
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "try_from_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__s");
                                            _s
                                        });
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "map_err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "e");
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"column `{}` could not be converted: {}\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__cn");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "e");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_question(&mut _s);
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "if");
                                    ::quote::__private::push_ident(&mut _s, "__c");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "len");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_ne(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__nrow");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Brace,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "return");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "core");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "result");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Result");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Err");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "std");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "format");
                                                    ::quote::__private::push_bang(&mut _s);
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        {
                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                            ::quote::__private::parse(&mut _s,
                                                                "\"column `{}` has length {} but data.frame has {} rows\"");
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "__cn");
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "__c");
                                                            ::quote::__private::push_dot(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "len");
                                                            ::quote::__private::push_group(&mut _s,
                                                                ::quote::__private::Delimiter::Parenthesis,
                                                                ::quote::__private::TokenStream::new());
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "__nrow");
                                                            _s
                                                        });
                                                    _s
                                                });
                                            ::quote::__private::push_semi(&mut _s);
                                            _s
                                        });
                                    ::quote::__private::push_ident(&mut _s, "__cols");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__c");
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__k");
                                    ::quote::__private::push_add_eq(&mut _s);
                                    ::quote::__private::parse(&mut _s, "1");
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "None");
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "break");
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "__cols");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
3356            let mut #cols_var: ::std::vec::Vec<::std::vec::Vec<#opt_elem_ty>> = {
3357                let mut __cols: ::std::vec::Vec<::std::vec::Vec<#opt_elem_ty>> = ::std::vec::Vec::new();
3358                let mut __k: usize = 1;
3359                loop {
3360                    let __cn = ::std::format!("{}_{}", #base_name, __k);
3361                    match __view.column_raw(&__cn) {
3362                        ::core::option::Option::Some(__s) => {
3363                            let __c: ::std::vec::Vec<#opt_elem_ty> =
3364                                <::std::vec::Vec<#opt_elem_ty> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__s)
3365                                    .map_err(|e| ::std::format!(
3366                                        "column `{}` could not be converted: {}",
3367                                        __cn, e
3368                                    ))?;
3369                            if __c.len() != __nrow {
3370                                return ::core::result::Result::Err(::std::format!(
3371                                    "column `{}` has length {} but data.frame has {} rows",
3372                                    __cn, __c.len(), __nrow
3373                                ));
3374                            }
3375                            __cols.push(__c);
3376                            __k += 1;
3377                        }
3378                        ::core::option::Option::None => break,
3379                    }
3380                }
3381                __cols
3382            };
3383        });
3384    }
3385
3386    // For each Struct field, build a densified sub-Vec<Option<Inner>>.
3387    // Approach: for each struct field base_name, collect the present_in indices from
3388    // the variant_infos, build a presence mask, select+strip_prefix the sub-frame,
3389    // densify it via select_rows, recurse via DataFrameRowConvert, scatter to
3390    // Vec<Option<Inner>> of length __nrow.
3391    let mut seen_struct: std::collections::HashSet<String> = std::collections::HashSet::new();
3392    for vi in variant_infos {
3393        for erf in &vi.fields {
3394            if let EnumResolvedField::Struct(data) = erf
3395                && seen_struct.insert(data.base_name.clone())
3396            {
3397                let inner_ty = &data.inner_ty;
3398                let base = &data.base_name;
3399                let prefix_lit = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_", data.base_name))
    })format!("{}_", data.base_name);
3400                let vec_var = match ::quote::__private::IdentFragmentAdapter(&data.base_name.replace('-',
                "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__sf_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__sf_{}", data.base_name.replace('-', "_"));
3401
3402                // Collect the variant names that contribute this field (for the mask).
3403                let contributing_variant_names: Vec<String> = variant_infos
3404                    .iter()
3405                    .filter(|vi2| {
3406                        vi2.fields.iter().any(
3407                            |f| #[allow(non_exhaustive_omitted_patterns)] match f {
    EnumResolvedField::Struct(d) if d.base_name == *base => true,
    _ => false,
}matches!(f, EnumResolvedField::Struct(d) if d.base_name == *base),
3408                        )
3409                    })
3410                    .map(|vi2| vi2.name.to_string())
3411                    .collect();
3412
3413                extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&vec_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__contributing");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "str");
                    _s
                });
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut contributing_variant_names, i) =
                            contributing_variant_names.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let contributing_variant_names =
                                match contributing_variant_names.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&contributing_variant_names,
                                &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__present_indices");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "usize");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "0");
                    ::quote::__private::push_dot2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__nrow");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "filter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__i");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__contributing");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "contains");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__tag");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Bracket,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__i");
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "as_str");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "collect");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__inner_result");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "if");
            ::quote::__private::push_ident(&mut _s, "__present_indices");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "is_empty");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "new");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__prefix");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "str");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::ToTokens::to_tokens(&prefix_lit, &mut _s);
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__names");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "__view");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "names");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Ok");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__n");
                                    _s
                                });
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__n");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__e");
                                    _s
                                });
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "return");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"struct column `{}`: the data.frame\'s column names: {}\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::ToTokens::to_tokens(&base, &mut _s);
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__e");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__sel");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "str");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__names");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "iter");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "filter");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__n");
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__n");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "starts_with");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__prefix");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "map");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__n");
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__n");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "as_str");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "collect");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "if");
                    ::quote::__private::push_ident(&mut _s, "__sel");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "is_empty");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "return");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s,
                                                "\"struct column `{}`: no columns with prefix `{}` found\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&base, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__prefix");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__sub_dense");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__view");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "select");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__sel");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "strip_prefix");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__prefix");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "select_rows");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s,
                                "__present_indices");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__out");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
                    ::quote::__private::push_ident(&mut _s, "as");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "DataFrameRowConvert");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "rows_from_dataframe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__sub_dense");
                            _s
                        });
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Some");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Ok");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__v");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__v");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Some");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__e");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "return");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"struct column `{}`: {}\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::ToTokens::to_tokens(&base, &mut _s);
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__e");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "None");
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "return");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"struct column `{}`: nested type has no data.frame reader\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::ToTokens::to_tokens(&base, &mut _s);
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__out");
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__result");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "0");
                    ::quote::__private::push_dot2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__nrow");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_underscore(&mut _s);
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "None");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "collect");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__dense_iter");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__inner_result");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__present_indices");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__result");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__i");
                            _s
                        });
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Some");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__dense_iter");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "next");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "expect");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"dense iter must match present count\"");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "__result");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
3414                    let mut #vec_var: ::std::vec::Vec<::core::option::Option<#inner_ty>> = {
3415                        // Build presence mask: row i is present iff its tag is one of the
3416                        // variants that contribute this Struct field.
3417                        let __contributing: &[&str] = &[#(#contributing_variant_names),*];
3418                        let __present_indices: ::std::vec::Vec<usize> = (0..__nrow)
3419                            .filter(|&__i| __contributing.contains(&__tag[__i].as_str()))
3420                            .collect();
3421
3422                        let __inner_result: ::std::vec::Vec<#inner_ty> = if __present_indices.is_empty() {
3423                            ::std::vec::Vec::new()
3424                        } else {
3425                            // Select the prefixed columns into a sub-frame, strip prefix,
3426                            // densify to present rows only, then recurse via inner reader.
3427                            let __prefix: &str = #prefix_lit;
3428                            let __names = match __view.names() {
3429                                ::core::result::Result::Ok(__n) => __n,
3430                                ::core::result::Result::Err(__e) => {
3431                                    return ::core::result::Result::Err(::std::format!(
3432                                        "struct column `{}`: the data.frame's column names: {}",
3433                                        #base, __e
3434                                    ));
3435                                }
3436                            };
3437                            let __sel: ::std::vec::Vec<&str> = __names
3438                                .iter()
3439                                .filter(|__n| __n.starts_with(__prefix))
3440                                .map(|__n| __n.as_str())
3441                                .collect();
3442                            if __sel.is_empty() {
3443                                return ::core::result::Result::Err(::std::format!(
3444                                    "struct column `{}`: no columns with prefix `{}` found",
3445                                    #base, __prefix
3446                                ));
3447                            }
3448                            // Each edit returns an owned, GC-rooted `BuiltDataFrame`
3449                            // (#1247): `select` roots the sub-frame, `strip_prefix`
3450                            // (inherent forward) carries the handle through its
3451                            // CHARSXP allocations, and `select_rows` roots the
3452                            // densified frame before the borrowed handle's root
3453                            // releases — every intermediate frame is rooted across
3454                            // the next step's allocations and the recursive read.
3455                            let __sub_dense = __view
3456                                .select(&__sel)
3457                                .strip_prefix(__prefix)
3458                                .select_rows(&__present_indices);
3459                            let __out = match <#inner_ty as ::miniextendr_api::dataframe::DataFrameRowConvert>::rows_from_dataframe(&__sub_dense) {
3460                                ::core::option::Option::Some(::core::result::Result::Ok(__v)) => __v,
3461                                ::core::option::Option::Some(::core::result::Result::Err(__e)) => {
3462                                    return ::core::result::Result::Err(::std::format!(
3463                                        "struct column `{}`: {}", #base, __e
3464                                    ));
3465                                }
3466                                ::core::option::Option::None => {
3467                                    return ::core::result::Result::Err(::std::format!(
3468                                        "struct column `{}`: nested type has no data.frame reader", #base
3469                                    ));
3470                                }
3471                            };
3472                            __out
3473                        };
3474
3475                        // Scatter dense Vec<Inner> back to Vec<Option<Inner>> of length __nrow.
3476                        let mut __result: ::std::vec::Vec<::core::option::Option<#inner_ty>> =
3477                            (0..__nrow).map(|_| ::core::option::Option::None).collect();
3478                        let mut __dense_iter = __inner_result.into_iter();
3479                        for &__i in &__present_indices {
3480                            __result[__i] = ::core::option::Option::Some(
3481                                __dense_iter.next().expect("dense iter must match present count")
3482                            );
3483                        }
3484                        __result
3485                    };
3486                });
3487            }
3488        }
3489    }
3490
3491    // For each Map field, read the parallel `<base>_keys` / `<base>_values`
3492    // list-columns back into `Vec<Option<Vec<K>>>` / `Vec<Option<Vec<V>>>`. The
3493    // writer emits these via `Vec<Option<Vec<_>>>: IntoR` (a VECSXP where absent-
3494    // variant rows are NULL and present rows are typed vectors), so the reader
3495    // walks the VECSXP: NULL → `None`, typed vector → `Some(Vec<elem>)`. The
3496    // per-row dispatch zips `keys[i]` and `values[i]` back into the map type.
3497    let emit_map_col_extract = |col_var: &syn::Ident, col_name: &str, elem_ty: &syn::Type| {
3498        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__col_sexp");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "column_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ok_or_else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"column `{}` is missing from the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "if");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SexpExt");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "is_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                    _s
                });
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__list");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "unsafe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "list");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "List");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "from_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__len");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__list");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "__v");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                    ::quote::__private::push_shr(&mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "with_capacity");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__len");
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_ident(&mut _s, "usize");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__j");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::parse(&mut _s, "0");
                    ::quote::__private::push_dot2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__elt");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__list");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "get");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__j");
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "unwrap");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "if");
                            ::quote::__private::push_ident(&mut _s, "__elt");
                            ::quote::__private::push_eq_eq(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "SEXP");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "nil");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__v");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "core");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "option");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Option");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "None");
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_ident(&mut _s, "else");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "let");
                                    ::quote::__private::push_ident(&mut _s, "__inner");
                                    ::quote::__private::push_colon(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_eq(&mut _s);
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "as");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "from_r");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "TryFromSexp");
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "try_from_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__elt");
                                            _s
                                        });
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "map_err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "e");
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"column `{}` element {} could not be converted to the expected type: {}\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__j");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "e");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_question(&mut _s);
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__v");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "core");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "option");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Option");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Some");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_ident(&mut _s, "__inner");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_ident(&mut _s, "__v");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "0");
                            ::quote::__private::push_dot2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "map");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_underscore(&mut _s);
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "None");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "collect");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` has length {} but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3499            let mut #col_var: ::std::vec::Vec<::core::option::Option<::std::vec::Vec<#elem_ty>>> = {
3500                let __col_sexp = __view.column_raw(#col_name).ok_or_else(|| {
3501                    ::std::format!("column `{}` is missing from the data.frame", #col_name)
3502                })?;
3503                // VECSXP list-column: NULL → None, typed vector → Some(Vec<elem>).
3504                // `SexpExt::is_list` via UFCS (avoids the `List::is_list` pair-list bug).
3505                if <::miniextendr_api::SEXP as ::miniextendr_api::SexpExt>::is_list(&__col_sexp) {
3506                    let __list = unsafe {
3507                        ::miniextendr_api::list::List::from_raw(__col_sexp)
3508                    };
3509                    let __len = __list.len();
3510                    let mut __v: ::std::vec::Vec<::core::option::Option<::std::vec::Vec<#elem_ty>>> =
3511                        ::std::vec::Vec::with_capacity(__len as usize);
3512                    for __j in 0..__len {
3513                        // in-bounds by construction (0..len)
3514                        let __elt = __list.get(__j).unwrap();
3515                        if __elt == ::miniextendr_api::SEXP::nil() {
3516                            __v.push(::core::option::Option::None);
3517                        } else {
3518                            let __inner: ::std::vec::Vec<#elem_ty> =
3519                                <::std::vec::Vec<#elem_ty> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__elt)
3520                                    .map_err(|e| ::std::format!(
3521                                        "column `{}` element {} could not be converted to the expected type: {}",
3522                                        #col_name, __j, e
3523                                    ))?;
3524                            __v.push(::core::option::Option::Some(__inner));
3525                        }
3526                    }
3527                    __v
3528                } else {
3529                    // Non-list column → no map present in any row.
3530                    (0..__nrow).map(|_| ::core::option::Option::None).collect()
3531                }
3532            };
3533            if #col_var.len() != __nrow {
3534                return ::core::result::Result::Err(::std::format!(
3535                    "column `{}` has length {} but data.frame has {} rows",
3536                    #col_name, #col_var.len(), __nrow
3537                ));
3538            }
3539        }
3540    };
3541    let mut seen_map: std::collections::HashSet<String> = std::collections::HashSet::new();
3542    for vi in variant_infos {
3543        for erf in &vi.fields {
3544            if let EnumResolvedField::Map(data) = erf
3545                && seen_map.insert(data.base_name.clone())
3546            {
3547                let keys_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
3548                let vals_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
3549                let keys_var = match ::quote::__private::IdentFragmentAdapter(&data.base_name.replace('-',
                "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_{}_keys", data.base_name.replace('-', "_"));
3550                let vals_var =
3551                    match ::quote::__private::IdentFragmentAdapter(&data.base_name.replace('-',
                "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_{0}_values",
                                arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_{}_values", data.base_name.replace('-', "_"));
3552                extracts.push(emit_map_col_extract(&keys_var, &keys_name, &data.key_ty));
3553                extracts.push(emit_map_col_extract(&vals_var, &vals_name, &data.val_ty));
3554            }
3555        }
3556    }
3557    // endregion
3558
3559    // region: per-row dispatch match arms
3560    let mut match_arms: Vec<TokenStream> = Vec::new();
3561    // Parallel variant: arms return Ok(row) instead of pushing to a Vec.
3562    let mut par_match_arms: Vec<TokenStream> = Vec::new();
3563
3564    for vi in variant_infos {
3565        let variant_name_str = vi.name.to_string();
3566        let variant_ident = &vi.name;
3567
3568        let arm_body = |take: bool| -> TokenStream {
3569            let values = vi
3570                .fields
3571                .iter()
3572                .map(|erf| enum_reader_field_value(erf, &variant_name_str, take));
3573            match vi.shape {
3574                VariantShape::Named => {
3575                    let names = vi.fields.iter().map(|erf| erf.rust_name());
3576                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_ident, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut names, i) = names.quote_into_iter();
                let has_iter = has_iter | i;
                #[allow(unused_mut)]
                let (mut values, i) = values.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let names =
                        match names.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    let values =
                        match values.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&names, &mut _s);
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::ToTokens::to_tokens(&values, &mut _s);
                }
            }
            _s
        });
    _s
}quote! { #row_name::#variant_ident { #(#names: #values),* } }
3577                }
3578                VariantShape::Tuple => {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_ident, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut values, i) = values.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let values =
                        match values.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&values, &mut _s);
                }
            }
            _s
        });
    _s
}quote! { #row_name::#variant_ident( #(#values),* ) },
3579                VariantShape::Unit => {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&variant_ident, &mut _s);
    _s
}quote! { #row_name::#variant_ident },
3580            }
3581        };
3582
3583        // Sequential arm: push onto __rows.
3584        let seq_body = arm_body(true);
3585        match_arms.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__rows");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "push");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&seq_body, &mut _s);
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3586            #variant_name_str => {
3587                __rows.push(#seq_body);
3588            }
3589        });
3590        // Parallel arm: return Ok(row_value).
3591        let par_body = arm_body(false);
3592        par_match_arms.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&variant_name_str, &mut _s);
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Ok");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&par_body, &mut _s);
            _s
        });
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! {
3593            #variant_name_str => ::core::result::Result::Ok(#par_body),
3594        });
3595    }
3596    // endregion
3597
3598    // region: sequential body
3599    let seq_body = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__view");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrame");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "from_sexp");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "sexp");
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map_err");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "e");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "e");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    ::quote::__private::push_question(&mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__view");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut extracts, i) = extracts.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let extracts =
                match extracts.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&extracts, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::__private::push_ident(&mut _s, "__rows");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__nrow");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::__private::push_ident(&mut _s, "__i");
    ::quote::__private::push_ident(&mut _s, "in");
    ::quote::__private::parse(&mut _s, "0");
    ::quote::__private::push_dot2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "match");
            ::quote::ToTokens::to_tokens(&tag_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "as_str");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut match_arms, i) = match_arms.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let match_arms =
                                match match_arms.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::ToTokens::to_tokens(&match_arms, &mut _s);
                        }
                    }
                    ::quote::__private::push_ident(&mut _s, "__unknown");
                    ::quote::__private::push_fat_arrow(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "return");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s,
                                                "\"unknown variant tag {:?} at row {}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__unknown");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__i");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Ok");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__rows");
            _s
        });
    _s
}quote! {
3600        let __view = ::miniextendr_api::dataframe::DataFrame::from_sexp(sexp)
3601            .map_err(|e| e.to_string())?;
3602        let __nrow = __view.nrow();
3603        #(#extracts)*
3604        let mut __rows: ::std::vec::Vec<Self> = ::std::vec::Vec::with_capacity(__nrow);
3605        for __i in 0..__nrow {
3606            match #tag_var[__i].as_str() {
3607                #(#match_arms)*
3608                __unknown => {
3609                    return ::core::result::Result::Err(::std::format!(
3610                        "unknown variant tag {:?} at row {}",
3611                        __unknown, __i
3612                    ));
3613                }
3614            }
3615        }
3616        ::core::result::Result::Ok(__rows)
3617    };
3618    // endregion
3619
3620    // region: parallel body
3621    // For shapes with Struct or factor fields, delegate to sequential (see
3622    // `par_delegates`). For pure-scalar/expansion shapes, extract all columns on
3623    // the R thread then parallelize per-row dispatch over pre-extracted owned Vecs.
3624    let par_body = if par_delegates {
3625        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "try_from_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "sexp");
            _s
        });
    _s
}quote! { Self::try_from_dataframe(sexp) }
3626    } else {
3627        // Extract all columns on the R thread, then parallelize per-row dispatch.
3628        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "use");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rayon_bridge");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rayon");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "prelude");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_star(&mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "optionals");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "parallel");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ensure_pool");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__view");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrame");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "from_sexp");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "sexp");
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map_err");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "e");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "e");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    ::quote::__private::push_question(&mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__view");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut extracts, i) = extracts.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let extracts =
                match extracts.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&extracts, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__rows");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::parse(&mut _s, "0");
            ::quote::__private::push_dot2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__nrow");
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_par_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "String");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::ToTokens::to_tokens(&tag_var, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__i");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "as_str");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut par_match_arms, i) =
                                    par_match_arms.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let par_match_arms =
                                        match par_match_arms.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&par_match_arms, &mut _s);
                                }
                            }
                            ::quote::__private::push_ident(&mut _s, "__unknown");
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Result");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"unknown variant tag {:?} at row {}\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__unknown");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__i");
                                                    _s
                                                });
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_question(&mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Ok");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__rows");
            _s
        });
    _s
}quote! {
3629            use ::miniextendr_api::rayon_bridge::rayon::prelude::*;
3630            ::miniextendr_api::optionals::parallel::ensure_pool();
3631            let __view = ::miniextendr_api::dataframe::DataFrame::from_sexp(sexp)
3632                .map_err(|e| e.to_string())?;
3633            let __nrow = __view.nrow();
3634            #(#extracts)*
3635            let __rows: ::std::vec::Vec<Self> = (0..__nrow)
3636                .into_par_iter()
3637                .map(|__i| -> ::core::result::Result<Self, ::std::string::String> {
3638                    match #tag_var[__i].as_str() {
3639                        #(#par_match_arms)*
3640                        __unknown => {
3641                            ::core::result::Result::Err(::std::format!(
3642                                "unknown variant tag {:?} at row {}",
3643                                __unknown, __i
3644                            ))
3645                        }
3646                    }
3647                })
3648                .collect::<::core::result::Result<::std::vec::Vec<Self>, _>>()?;
3649            ::core::result::Result::Ok(__rows)
3650        }
3651    };
3652    // endregion
3653
3654    Some({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Read an R `data.frame` directly into a `Vec<Self>` (sequential).\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Reads the tag column first, then per-row dispatches to the active variant\'s\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" field assemblers. Each schema column is pre-extracted (NA-aware, ALTREP-\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" materialising). Returns `Err` with a descriptive message if a column is\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" missing, mis-typed, or if an unknown tag value is encountered.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" This is the one-call `SEXP \u{2192} Vec<Self>` reader; the same conversion is also\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" reachable via the boundary-crossing [`FromDataFrame`] trait as\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" `Vec::<Self>::from_dataframe(&df)`.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" [`FromDataFrame`]: ::miniextendr_api::dataframe::FromDataFrame\"");
            _s
        });
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::__private::push_ident(&mut _s, "try_from_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "sexp");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_rarrow(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&seq_body, &mut _s);
            _s
        });
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__dataframe_row_when_rayon");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Read an R `data.frame` directly into a `Vec<Self>` (parallel).\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\"\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Mirrors [`Self::try_from_dataframe`] but assembles rows off the R thread via\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" rayon. All SEXP access happens up front on the R main thread; the\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" `into_par_iter()` region touches only pre-extracted owned data. Shapes with\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" struct-flatten/nested-enum or factor fields delegate to the sequential\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\" reader instead.\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "allow");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "unused_mut");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "pub");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "try_from_dataframe_par");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "sexp");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "String");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&par_body, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
3655        /// Read an R `data.frame` directly into a `Vec<Self>` (sequential).
3656        ///
3657        /// Reads the tag column first, then per-row dispatches to the active variant's
3658        /// field assemblers. Each schema column is pre-extracted (NA-aware, ALTREP-
3659        /// materialising). Returns `Err` with a descriptive message if a column is
3660        /// missing, mis-typed, or if an unknown tag value is encountered.
3661        ///
3662        /// This is the one-call `SEXP → Vec<Self>` reader; the same conversion is also
3663        /// reachable via the boundary-crossing [`FromDataFrame`] trait as
3664        /// `Vec::<Self>::from_dataframe(&df)`.
3665        ///
3666        /// [`FromDataFrame`]: ::miniextendr_api::dataframe::FromDataFrame
3667        pub fn try_from_dataframe(
3668            sexp: ::miniextendr_api::SEXP,
3669        ) -> ::core::result::Result<::std::vec::Vec<Self>, ::std::string::String> {
3670            #seq_body
3671        }
3672
3673        // api-side rayon gate (#1117).
3674        ::miniextendr_api::__dataframe_row_when_rayon! {
3675            /// Read an R `data.frame` directly into a `Vec<Self>` (parallel).
3676            ///
3677            /// Mirrors [`Self::try_from_dataframe`] but assembles rows off the R thread via
3678            /// rayon. All SEXP access happens up front on the R main thread; the
3679            /// `into_par_iter()` region touches only pre-extracted owned data. Shapes with
3680            /// struct-flatten/nested-enum or factor fields delegate to the sequential
3681            /// reader instead.
3682            // The extracted columns are `mut` for the sequential reader, which
3683            // moves cells out of them; this one only reads them.
3684            #[allow(unused_mut)]
3685            pub fn try_from_dataframe_par(
3686                sexp: ::miniextendr_api::SEXP,
3687            ) -> ::core::result::Result<::std::vec::Vec<Self>, ::std::string::String> {
3688                #par_body
3689            }
3690        }
3691    })
3692}
3693// endregion