swc-project/swc · error

named enum unsupported

Error message

named enum unsupported

What it means

When expanding the #[encoding(unknown)] arm, the Encode derive matches on unknown.fields and only handles syn::Fields::Unnamed; a named-field variant like `Unknown { tag, value }` or a unit variant `Unknown` falls into the catch-all and panics 'named enum unsupported'. The unknown variant must be positional: (tag) or (tag, value).

Source

Thrown at crates/ast_node/src/encoding/encode.rs:111

                    match &unknown.fields {
                        syn::Fields::Unnamed(fields) => match fields.unnamed.len() {
                            1 => {
                                assert_eq!(enum_type, EnumType::Unit);
                                syn::parse_quote! {
                                    #ident::#name(tag)
                                        => tag.encode(writer)?,
                                }
                            }
                            2 => {
                                assert_eq!(enum_type, EnumType::One);
                                syn::parse_quote! {
                                    #ident::#name(tag, value)
                                        => cbor4ii::core::types::Tag((*tag).into(), &*value).encode(writer)?,
                                }
                            }
                            _ => panic!("unknown member must be a tag and a value"),
                        },
                        _ => panic!("named enum unsupported"),
                    }
                });

            if matches!(enum_type, EnumType::Struct) {
                assert!(
                    unknown_arm.is_none(),
                    "struct enum does not allow unknown variants"
                );
            }

            let mut discriminant: u32 = 0;
            let fields = iter.map(|field| -> syn::Arm {
                match field.discriminant.as_ref() {
                    Some((_, syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Int(lit), .. }))) => {
                        discriminant = lit.base10_parse::<u32>().unwrap();
                    },
                    Some(_) => panic!("unsupported discriminant type"),
                    None => (),

View on GitHub (pinned to 5176682b65)

Solutions

1. Rewrite the variant with positional fields: `Unknown(u32)` or `Unknown(u32, Unknown)`.
2. Use #[ast_node] to generate the variant in the correct shape.

Example fix

// before
#[encoding(unknown)]
Unknown { tag: u32, value: Unknown }

// after
#[encoding(unknown)]
Unknown(u32, Unknown)

When it happens

Trigger: derive(Encode) on an enum whose #[encoding(unknown)] variant uses named fields or has no fields.

Common situations: Rewriting the generated Unknown variant with named fields for readability; porting serde enum conventions into swc codec types.

Related errors

• unknown member must be a tag and a value
• unknown member must be a tag and a value
• named enum unsupported
• more than 1 unnamed member field are not allowed
• enum member types must be consistent: {:?}

AI-assisted analysis of swc-project/swc@5176682b65 (2026-08-17). Data as JSON: /api/errors/622e5a9ab0462667. Report an issue: GitHub.