Finchie/l10n_embed - Change R2BAN2V6VS4OBNG6MK5BOUYQCJMGLD37IIE5RX4HXZLQ3C5AQRHAC

Add support for unnamed fields in `l10n_embed_derive`

When a struct or enum variant has a single unnamed field, their implementation of Localize now forwards to the field's implementation.

Created by finchie on August 13, 2025

R2BAN2V6VS4OBNG6MK5BOUYQCJMGLD37IIE5RX4HXZLQ3C5AQRHAC

Dependencies

In channels

main

Change contents

File addition: unnamed_fields.rs (----------)

[4.101]

//! End-to-end test for unnamed field support in the `l10n_embed_derive` macro
mod common;
use icu_locale::{Locale, locale};
use l10n_embed::Localize;
use l10n_embed_derive::localize;
const DEFAULT_LOCALE: Locale = locale!("en-US");
const EXPECTED_LOCALES: [Locale; 4] = [
    locale!("zh-CN"),
    locale!("en-US"),
    locale!("ja-JP"),
    locale!("fr"),
];
pub struct LocalizableType;
impl Localize for LocalizableType {
    fn available_locales(&self) -> Vec<Locale> {
        EXPECTED_LOCALES.to_vec()
    }
    fn localize_for(&self, locale: &Locale) -> String {
        format!("Localized with locale: {locale}")
    }
}
#[localize("tests/locale/**/basic.ftl")]
pub struct MessageStruct(LocalizableType);
#[localize("tests/locale/**/basic.ftl")]
pub enum MessageEnum {
    Greeting { name: String },
    Forward(LocalizableType),
}
mod forward {
    use super::common::compare_message;
    use super::{DEFAULT_LOCALE, EXPECTED_LOCALES, LocalizableType, MessageEnum, MessageStruct};
    use l10n_embed::Localize;
    use pretty_assertions::assert_eq;
    #[test]
    fn message() {
        let expected = "Localized with locale: en-US";
        compare_message(MessageStruct(LocalizableType), expected, DEFAULT_LOCALE);
        compare_message(
            MessageEnum::Forward(LocalizableType),
            expected,
            DEFAULT_LOCALE,
        );
    }
    #[test]
    fn available_locales() {
        let expected_locales = EXPECTED_LOCALES.to_vec();
        assert_eq!(
            expected_locales,
            MessageStruct(LocalizableType).available_locales()
        );
        assert_eq!(
            expected_locales,
            MessageEnum::Forward(LocalizableType).available_locales()
        );
    }
}
/// Ensure other enum variants are not affected
mod preserves_enum_variants {
    use super::common::compare_message;
    use super::{DEFAULT_LOCALE, LocalizableType, MessageEnum};
    use l10n_embed::Localize;
    use pretty_assertions::{assert_eq, assert_ne};
    #[test]
    fn message() {
        compare_message(
            MessageEnum::Greeting {
                name: String::from("Ferris"),
            },
            "Hello, Ferris!",
            DEFAULT_LOCALE,
        );
    }
    #[test]
    fn available_locales() {
        let greeting = MessageEnum::Greeting {
            name: String::from("Ferris"),
        };
        assert_ne!(
            greeting.available_locales(),
            MessageEnum::Forward(LocalizableType).available_locales()
        );
        assert_eq!(vec![DEFAULT_LOCALE], greeting.available_locales());
    }
}

Insertion in l10n_embed_derive/src/macro_impl/mod.rs at line 2 [5.76]
[5.96]
[5.96]
```
use crate::macro_impl::derive::ReferenceKind;
```
Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 14 [5.76]
B:BD[6.24] → [7.0:29]
```
pub enum UnsupportedReason {
```
[6.24]
[7.29]
```
pub enum UnsupportedError {
```

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 16 [5.76]

B:BD[7.70] → [7.70:293]

    Union,
    #[error("Unnamed fields are not supported")]
    UnnamedFields,
}
#[derive(Debug, Error)]
#[error("Unsupported Rust code")]
pub struct UnsupportedError {
    span: syn::Ident,
    reason: UnsupportedReason,

[7.70]

[7.293]

    Union { span: syn::Ident },
    #[error("Only 1 unnamed field is supported")]
    UnnamedFields {
        span: syn::Ident,
        field_count: usize,
    },

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 76 [5.76]

∅:D[8.210] → [5.879:978]

B:BD[5.879] → [5.879:978]

        syn::Data::Struct(_struct_data) => derive::locales_for_ident(&group, &derive_input.ident),

[8.210]

[5.978]

        syn::Data::Struct(struct_data) => derive::locales_for_ident(
            &group,
            &struct_data.fields,
            ReferenceKind::StructField,
            &derive_input.ident,
        ),

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 84 [5.76]

B:BD[7.398] → [7.398:464]

            return Err(MacroError::Unsupported(UnsupportedError {

[7.398]

[7.464]

            return Err(MacroError::Unsupported(UnsupportedError::Union {

Deletion in l10n_embed_derive/src/macro_impl/mod.rs at line 86 [5.76]
B:BD[7.514] → [7.514:564]
```
                reason: UnsupportedReason::Union,
```

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 96 [5.76]

B:BD[7.624] → [7.624:690]

            return Err(MacroError::Unsupported(UnsupportedError {

[7.624]

[7.690]

            return Err(MacroError::Unsupported(UnsupportedError::Union {

Deletion in l10n_embed_derive/src/macro_impl/mod.rs at line 98 [5.76]
B:BD[7.740] → [7.740:790]
```
                reason: UnsupportedReason::Union,
```

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 109 [5.76]

B:BD[9.1700] → [9.1700:1976]

B:BD[9.1976] → [2.0:100]

∅:D[2.100] → [7.836:1022]

B:BD[7.836] → [7.836:1022]

B:BD[7.1022] → [10.1119:1140]

∅:D[10.1140] → [7.1042:1056]

B:BD[7.1042] → [7.1042:1056]

∅:D[7.1056] → [9.2002:2013]

B:BD[9.2002] → [9.2002:2013]

    let named_fields: Vec<&syn::Type> = match &derive_input.data {
        syn::Data::Struct(struct_data) => match &struct_data.fields {
            syn::Fields::Named(named_fields) => {
                named_fields.named.iter().map(|field| &field.ty).collect()
            }
            syn::Fields::Unit => Vec::new(),
            syn::Fields::Unnamed(_unnamed_fields) => {
                return Err(MacroError::Unsupported(UnsupportedError {
                    span: derive_input.ident.clone(),
                    reason: UnsupportedReason::UnnamedFields,
                }));
            }
        },

[9.1700]

[9.2013]

    let field_types: Vec<&syn::Type> = match &derive_input.data {
        syn::Data::Struct(struct_data) => {
            types_for_fields(&struct_data.fields, derive_input.ident.clone())?
        }

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 116 [5.76]

B:BD[9.2103] → [7.1057:1108]

∅:D[7.1108] → [9.2159:2213]

B:BD[9.2159] → [9.2159:2213]

B:BD[9.2213] → [7.1109:1192]

∅:D[7.1192] → [9.2282:2300]

B:BD[9.2282] → [9.2282:2300]

B:BD[9.2300] → [2.101:441]

∅:D[2.441] → [9.2330:2345]

∅:D[7.1393] → [9.2330:2345]

B:BD[9.2330] → [9.2330:2345]

B:BD[9.2345] → [7.1394:1453]

            .map(|variant| match &variant.fields {
                syn::Fields::Named(named_fields) => {
                    Ok(named_fields.named.iter().map(|field| &field.ty).collect())
                }
                syn::Fields::Unit => Ok(Vec::new()),
                syn::Fields::Unnamed(_unnamed_fields) => {
                    Err(MacroError::Unsupported(UnsupportedError {
                        span: variant.ident.clone(),
                        reason: UnsupportedReason::UnnamedFields,
                    }))
                }
            })
            .collect::<Result<Vec<Vec<&syn::Type>>, _>>()?

[9.2103]

[7.1453]

            .map(|variant| types_for_fields(&variant.fields, variant.ident.clone()))
            .collect::<Result<Vec<Vec<&syn::Type>>, UnsupportedError>>()?

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 121 [5.76]

B:BD[9.2369] → [9.2369:2419]

        syn::Data::Union(_union_data) => todo!(),

[9.2369]

[9.2419]

        syn::Data::Union(_union_data) => {
            return Err(MacroError::Unsupported(UnsupportedError::Union {
                span: derive_input.ident.clone(),
            }));
        }

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 130 [5.76]

B:BD[9.2536] → [9.2536:2745]

B:BD[9.2745] → [11.991:1063]

∅:D[12.178] → [9.2822:2834]

∅:D[11.1063] → [9.2822:2834]

B:BD[9.2822] → [9.2822:2834]

    let additional_bounds = named_fields
        .into_iter()
        .map(|field| -> syn::WherePredicate {
            // Attribute this bound to the original source code
            let span = field.span();
            parse_quote_spanned!(span=> #field: ::l10n_embed::Localize)
        });

[9.2536]

[9.2834]

    let additional_bounds = field_types.into_iter().map(|field| -> syn::WherePredicate {
        // Attribute this bound to the original source code
        let span = field.span();
        parse_quote_spanned!(span=> #field: ::l10n_embed::Localize)
    });

Insertion in l10n_embed_derive/src/macro_impl/mod.rs at line 168 [5.76]

[5.2182]


fn types_for_fields(
    fields: &syn::Fields,
    span: syn::Ident,
) -> Result<Vec<&syn::Type>, UnsupportedError> {
    match fields {
        syn::Fields::Named(named_fields) => {
            Ok(named_fields.named.iter().map(|field| &field.ty).collect())
        }
        syn::Fields::Unit => Ok(Vec::new()),
        syn::Fields::Unnamed(unnamed_fields) => {
            let unnamed_field_types: Vec<&syn::Type> = unnamed_fields
                .unnamed
                .iter()
                .map(|field| &field.ty)
                .collect();
            match unnamed_field_types.len() {
                1 => Ok(unnamed_field_types),
                _ => Err(UnsupportedError::UnnamedFields {
                    span,
                    field_count: unnamed_field_types.len(),
                }),
            }
        }
    }
}

Replacement in l10n_embed_derive/src/macro_impl/error.rs at line 2 [14.985]

B:BD[7.1515] → [13.681:757]

    MacroError, ParseError, UnsupportedError, UnsupportedReason, attribute,

[7.1515]

[7.1530]

    MacroError, ParseError, UnsupportedError, attribute,

Replacement in l10n_embed_derive/src/macro_impl/error.rs at line 107 [14.985]

B:BD[7.1723] → [7.1723:1838]

    match error.reason {
        UnsupportedReason::Union => emit_error! { error.span, "unions are not supported";

[7.1723]

[7.1838]

    match error {
        UnsupportedError::Union { span } => emit_error! { span, "unions are not supported";

Replacement in l10n_embed_derive/src/macro_impl/error.rs at line 111 [14.985]

B:BD[7.1903] → [7.1903:2111]

B:BD[7.2111] → [15.801:898]

        UnsupportedReason::UnnamedFields => {
            emit_error! { error.span, "only named fields are supported";
                help = "Each field needs a name so it can be referenced by Fluent code";
                note = "There must be at least one named field (unit structs are unsupported!)";

[7.1903]

[15.898]

        UnsupportedError::UnnamedFields { span, field_count } => {
            emit_error! { span, "only 1 unnamed field is supported, got {} fields", field_count;
                help = "When there are multiple fields, each field needs a name so it can be referenced by Fluent code";
                note = "Using a single unnamed field forwards to that field's implementation of `Localize`";

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 9 [16.39]
B:BD[7.2296] → [7.2296:2358]
```
use super::{MacroError, UnsupportedError, UnsupportedReason};
```
[7.2296]
[17.9191]
```
use super::{MacroError, UnsupportedError};
```
Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 26 [16.39]
∅:D[6.1003] → [5.3156:3186]
B:BD[18.178] → [5.3156:3186]
```
    reference_kind: &Context,
```
[6.1003]
[6.1004]
```
    context: &Context,
```

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 28 [16.39]

B:BD[6.1051] → [6.1051:1135]

    let canonical_message = group.remove_canonical_message(ident, reference_kind)?;

[6.1051]

[16.397]

    let canonical_message = group.remove_canonical_message(ident, context)?;

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 31 [16.39]

B:BD[18.403] → [6.1136:1196]

        .remove_additional_messages(ident, reference_kind)?

[18.403]

[18.453]

        .remove_additional_messages(ident, context)?

Insertion in l10n_embed_derive/src/macro_impl/derive.rs at line 68 [16.39]

[18.521]

fn expr_for_unnamed_fields(
    unnamed_fields: &syn::FieldsUnnamed,
    ident: &syn::Ident,
    context: &Context,
) -> Result<TokenStream, UnsupportedError> {
    let field_count = unnamed_fields.unnamed.iter().count();
    if field_count != 1 {
        return Err(UnsupportedError::UnnamedFields {
            span: ident.clone(),
            field_count,
        });
    }
    let field_reference = match context.reference_kind {
        ReferenceKind::EnumField => quote!(unnamed_field),
        ReferenceKind::StructField => quote!(self.0),
    };
    Ok(quote!(#field_reference.localize_for(locale)))
}

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 105 [16.39]

B:BD[19.45] → [20.1348:1481]

pub fn locales_for_ident(group: &fluent::Group, ident: &syn::Ident) -> TokenStream {
    let id = ident.to_string().to_kebab_case();

[19.45]

[20.1481]

pub fn locales_for_ident(
    group: &fluent::Group,
    fields: &syn::Fields,
    reference_kind: ReferenceKind,
    ident: &syn::Ident,
) -> TokenStream {
    match fields {
        // Provide available locales based on what Fluent source files are available
        syn::Fields::Named(_) | syn::Fields::Unit => {
            let id = ident.to_string().to_kebab_case();

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 116 [16.39]

B:BD[20.1482] → [20.1482:1689]

    let locale_literals = group
        .locales_for_message(&id)
        .map(|locale| locale.id.to_string())
        .map(|locale_string| syn::LitStr::new(&locale_string, proc_macro2::Span::call_site()));

[20.1482]

[20.1689]

            let locale_literals = group
                .locales_for_message(&id)
                .map(|locale| locale.id.to_string())
                .map(|locale_string| {
                    syn::LitStr::new(&locale_string, proc_macro2::Span::call_site())
                });
            quote!(
                vec![self.canonical_locale(), #(::l10n_embed::macro_prelude::icu_locale::locale!(#locale_literals)),*]
            )
        }
        // Forward to the unnamed field's implementation
        syn::Fields::Unnamed(_unnamed_fields) => {
            let unnamed_field_ident = match reference_kind {
                ReferenceKind::EnumField => quote!(unnamed_field),
                ReferenceKind::StructField => quote!(self.0),
            };

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 134 [16.39]

B:BD[20.1690] → [20.1690:1776]

B:BD[20.1776] → [3.843:972]

    // There is only one message for this struct, so just list every supported locale
    quote!(
        vec![self.canonical_locale(), #(::l10n_embed::macro_prelude::icu_locale::locale!(#locale_literals)),*]
    )

[20.1690]

[20.1841]

            quote!(#unnamed_field_ident.available_locales())
        }
    }

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 145 [16.39]

B:BD[18.1200] → [18.1200:1236]

B:BD[18.1236] → [5.3187:3241]

∅:D[5.3241] → [18.1293:1348]

∅:D[17.9823] → [18.1293:1348]

B:BD[18.1293] → [18.1293:1348]

B:BD[18.1348] → [17.9824:9880]

∅:D[17.9880] → [18.1394:1468]

B:BD[18.1394] → [18.1394:1468]

B:BD[18.1468] → [17.9881:9946]

∅:D[17.9946] → [18.1527:1538]

B:BD[18.1527] → [18.1527:1538]

B:BD[18.1538] → [2.442:481]

    let references = match fields {
        syn::Fields::Named(named_fields) => Context {
            // Reference using `self.{reference_name}`
            reference_kind: ReferenceKind::StructField,
            // Create a list of unique field names that can be referenced
            valid_references: unique_named_fields(named_fields),
        },
        syn::Fields::Unit => Context {

[18.1200]

[2.481]

    let context = match fields {
        syn::Fields::Named(named_fields) => {
            Context {
                // Reference using `self.{reference_name}`
                reference_kind: ReferenceKind::StructField,
                // Create a list of unique field names that can be referenced
                valid_references: unique_named_fields(named_fields),
            }
        }
        syn::Fields::Unit | syn::Fields::Unnamed(_) => Context {

Deletion in l10n_embed_derive/src/macro_impl/derive.rs at line 158 [16.39]

B:BD[2.594] → [2.594:645]

∅:D[2.645] → [7.2414:2575]

B:BD[7.2414] → [7.2414:2575]

B:BD[7.2575] → [10.1290:1307]

∅:D[10.1307] → [7.2591:2601]

B:BD[7.2591] → [7.2591:2601]

        syn::Fields::Unnamed(_unnamed_fields) => {
            return Err(MacroError::Unsupported(UnsupportedError {
                span: ident.clone(),
                reason: UnsupportedReason::UnnamedFields,
            }));
        }

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 160 [16.39]

B:BD[18.1628] → [7.2602:2660]

    Ok(expr_for_message(&mut group, ident, &references)?)

[18.1628]

[21.1589]

    Ok(match fields {
        syn::Fields::Named(_) | syn::Fields::Unit => expr_for_message(&mut group, ident, &context)?,
        syn::Fields::Unnamed(unnamed_fields) => {
            expr_for_unnamed_fields(unnamed_fields, ident, &context)?
        }
    })

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 177 [16.39]

B:BD[20.2183] → [20.2183:2630]

        // Simplify match code by always ignoring enum fields (even if they don't exist)
        // We are matching the variant name, not any data, so each arm will have something like:
        // Self::VariantName { .. }
        // Even if `Self::VariantName` doesn't contain any data
        let locales_for_variant = locales_for_ident(group, variant_ident);
        match_arms.push(quote!(Self::#variant_ident { .. } => #locales_for_variant));

[20.2183]

[20.2630]

        let destructuring_pattern = match &enum_variant.fields {
            // Simplify match code by always ignoring enum fields (even if they don't exist)
            // We are matching the variant name, not any data, so each arm will have something like:
            // Self::VariantName { .. }
            // Even if `Self::VariantName` doesn't contain any data
            syn::Fields::Named(_) | syn::Fields::Unit => quote!(Self::#variant_ident { .. }),
            // Bind the single unnamed field so we can use its implementation of `Localize::available_locales()`
            syn::Fields::Unnamed(_unnamed_fields) => quote!(Self::#variant_ident(unnamed_field)),
        };
        let locales_for_variant = locales_for_ident(
            group,
            &enum_variant.fields,
            ReferenceKind::EnumField,
            variant_ident,
        );
        match_arms.push(quote!(#destructuring_pattern => #locales_for_variant));

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 223 [16.39]

B:BD[2.709] → [2.709:764]

∅:D[2.764] → [7.2720:2906]

B:BD[7.2720] → [7.2720:2906]

B:BD[7.2906] → [10.1308:1329]

            syn::Fields::Unnamed(_unnamed_fields) => {
                return Err(MacroError::Unsupported(UnsupportedError {
                    span: enum_variant.ident.clone(),
                    reason: UnsupportedReason::UnnamedFields,
                }));

[2.709]

[7.2926]

            syn::Fields::Unnamed(unnamed_fields) => {
                let field_count = unnamed_fields.unnamed.iter().count();
                if field_count != 1 {
                    return Err(MacroError::Unsupported(UnsupportedError::UnnamedFields {
                        span: enum_variant.ident.clone(),
                        field_count,
                    }));
                }
                quote!(#variant_pascal_case(unnamed_field))

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 236 [16.39]

B:BD[4.83] → [18.1732:1786]

        let references = match &enum_variant.fields {

[4.83]

[5.3242]

        let context = match &enum_variant.fields {

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 241 [16.39]

B:BD[18.1973] → [2.765:808]

            syn::Fields::Unit => Context {

[18.1973]

[2.808]

            syn::Fields::Unit | syn::Fields::Unnamed(_) => Context {

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 245 [16.39]

B:BD[2.931] → [2.931:986]

∅:D[2.986] → [7.2960:3146]

B:BD[7.2960] → [7.2960:3146]

B:BD[7.3146] → [10.1330:1351]

            syn::Fields::Unnamed(_unnamed_fields) => {
                return Err(MacroError::Unsupported(UnsupportedError {
                    span: enum_variant.ident.clone(),
                    reason: UnsupportedReason::UnnamedFields,
                }));

[2.931]

[7.3166]

        };
        let arm_body = match &enum_variant.fields {
            syn::Fields::Named(_) | syn::Fields::Unit => {
                expr_for_message(&mut group, &enum_variant.ident, &context)?
            }
            syn::Fields::Unnamed(unnamed_fields) => {
                expr_for_unnamed_fields(unnamed_fields, &enum_variant.ident, &context)?

Deletion in l10n_embed_derive/src/macro_impl/derive.rs at line 255 [16.39]
B:BD[18.2074] → [18.2074:2075]
B:BD[18.2075] → [6.1347:1435]
```
        let arm_body = expr_for_message(&mut group, &enum_variant.ident, &references)?;
```