DioxusLabs/dioxus · error · syn::Error

Enums must be repr(C, u*)

Error message

Enums must be repr(C, u*)

What it means

Compile-time check in derive_parse: an enum with fielded variants was annotated without `#[repr(C, ...)]` (repr_c is false while variants_have_fields is true). Const serialization requires a C layout with a u* discriminant to reason about memory layout; the faulting input is the enum's repr attribute.

Solutions

1. Mark the enum with a combined C and integer repr, e.g. #[repr(C, u8)].

When it happens

Trigger: Thrown at packages/const-serialize-macro/src/lib.rs:150 when the library encounters an invalid state.

Common situations: See trigger scenarios.

AI-assisted analysis of DioxusLabs/dioxus@24f6a829df (2026-08-23). Data as JSON: /api/errors/fe25fac7a77db597. Report an issue: GitHub.

Appendix: source

Thrown at packages/const-serialize-macro/src/lib.rs:150

                            // #[repr(u64)]
                            if meta.path.is_ident("u64") {
                                discriminant_size = Some(4);
                                return Ok(());
                            }

                            Err(meta.error("unrecognized repr"))
                        })
                    {
                        return err.to_compile_error().into();
                    }
                }

                let variants_have_fields = data
                    .variants
                    .iter()
                    .any(|variant| !variant.fields.is_empty());
                if !repr_c && variants_have_fields {
                    return syn::Error::new(input.ident.span(), "Enums must be repr(C, u*)")
                        .to_compile_error()
                        .into();
                }

                if discriminant_size.is_none() {
                    return syn::Error::new(input.ident.span(), "Enums must be repr(u*)")
                        .to_compile_error()
                        .into();
                }

                let ty = &input.ident;
                let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
                let mut where_clause = where_clause.cloned();
                add_bounds(&mut where_clause, &input.generics, &krate);
                let mut last_discriminant = None;
                let variants = data.variants.iter().map(|variant| {
                    let discriminant = variant
                        .discriminant

View on GitHub (pinned to 24f6a829df)