Finchie/l10n_embed - Change YZ6PVVQCLWYRFM33CH6BDB7U6BSP5PM5LH3FMKRXV3BH5KCRFM4AC

Add error handling for common unsupported Rust code

Now returns a nicely formatted error instead of panicking, although it could probably be a bit more helpful if more context was included in UnsupportedError

Created by finchie on April 2, 2025

YZ6PVVQCLWYRFM33CH6BDB7U6BSP5PM5LH3FMKRXV3BH5KCRFM4AC

Dependencies

In channels

main

Change contents

Insertion in fluent_embed_derive/src/macro_impl/mod.rs at line 13 [4.76]

[3.24]

[4.295]

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

Insertion in fluent_embed_derive/src/macro_impl/mod.rs at line 32 [4.76]
[3.64]
[4.458]
```
    Unsupported(#[from] UnsupportedError),
```

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 67 [4.76]

B:BD[4.1071] → [4.1071:1111]

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

[4.1071]

[4.1111]

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

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 80 [4.76]

B:BD[4.1404] → [4.1404:1444]

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

[4.1404]

[4.1444]

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

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 100 [4.76]

B:BD[2.1976] → [2.1976:2002]

            _ => todo!(),

[2.1976]

[2.2002]

            _ => {
                return Err(MacroError::Unsupported(UnsupportedError {
                    span: derive_input.ident.clone(),
                    reason: UnsupportedReason::UnnamedFields,
                }))
            }

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 110 [4.76]

B:BD[2.2103] → [2.2103:2159]

            .flat_map(|variant| match &variant.fields {

[2.2103]

[2.2159]

            .map(|variant| match &variant.fields {

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 112 [4.76]

B:BD[2.2213] → [2.2213:2282]

                    named_fields.named.iter().map(|field| &field.ty)

[2.2213]

[2.2282]

                    Ok(named_fields.named.iter().map(|field| &field.ty).collect())

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 114 [4.76]

B:BD[2.2300] → [2.2300:2330]

                _ => todo!(),

[2.2300]

[2.2330]

                _ => Err(MacroError::Unsupported(UnsupportedError {
                    span: variant.ident.clone(),
                    reason: UnsupportedReason::UnnamedFields,
                })),

Insertion in fluent_embed_derive/src/macro_impl/mod.rs at line 119 [4.76]

[2.2345]

            .collect::<Result<Vec<Vec<&syn::Type>>, _>>()?
            .into_iter()
            .flatten()

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 1 [5.985]

B:BD[5.985] → [3.65:129]

use super::{attribute, fluent, fluent::GroupError, MacroError};

[5.985]

[5.1027]

use super::{
    attribute,
    fluent::{self, GroupError},
    MacroError, UnsupportedError, UnsupportedReason,
};

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 92 [5.985]

B:BD[3.829] → [3.829:868]

        help = "{}", matched_locales},

[3.829]

[3.868]

            help = "{}", matched_locales;
        },
    }
}
fn unsupported(error: UnsupportedError) {
    match error.reason {
        UnsupportedReason::Union => emit_error! { error.span, "unions are not supported";
            help = "Use a `struct` or `enum` instead"
        },
        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!)"
            }
        }

Insertion in fluent_embed_derive/src/macro_impl/error.rs at line 115 [5.985]
[3.943]
[5.5206]
```
        MacroError::Unsupported(error) => unsupported(error),
```
Insertion in fluent_embed_derive/src/macro_impl/derive.rs at line 8 [8.39]
[6.64]
[7.9191]
```
use super::{MacroError, UnsupportedError, UnsupportedReason};
```
Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 92 [8.39]
B:BD[9.1098] → [3.1197:1244]
```
) -> Result<TokenStream, fluent::GroupError> {
```
[9.1098]
[9.1138]
```
) -> Result<TokenStream, MacroError> {
```

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 101 [8.39]

B:BD[9.1538] → [9.1538:1620]

        syn::Fields::Unnamed(_) => todo!(),
        syn::Fields::Unit => todo!(),

[9.1538]

[9.1620]

        _ => {
            return Err(MacroError::Unsupported(UnsupportedError {
                span: ident.clone(),
                reason: UnsupportedReason::UnnamedFields,
            }))
        }

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 109 [8.39]
B:BD[9.1628] → [3.1245:1298]
```
    expr_for_message(&mut group, ident, &references)
```
[9.1628]
[10.1589]
```
    Ok(expr_for_message(&mut group, ident, &references)?)
```
Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 139 [8.39]
B:BD[10.1695] → [3.1299:1346]
```
) -> Result<TokenStream, fluent::GroupError> {
```
[10.1695]
[10.1714]
```
) -> Result<TokenStream, MacroError> {
```

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 156 [8.39]

B:BD[10.2579] → [10.2579:2669]

            syn::Fields::Unnamed(_) => todo!(),
            syn::Fields::Unit => todo!(),

[10.2579]

[10.2669]

            _ => {
                return Err(MacroError::Unsupported(UnsupportedError {
                    span: enum_variant.ident.clone(),
                    reason: UnsupportedReason::UnnamedFields,
                }))
            }

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 169 [8.39]

B:BD[9.1973] → [9.1973:2063]

            syn::Fields::Unnamed(_) => todo!(),
            syn::Fields::Unit => todo!(),

[9.1973]

[9.2063]

            _ => {
                return Err(MacroError::Unsupported(UnsupportedError {
                    span: enum_variant.ident.clone(),
                    reason: UnsupportedReason::UnnamedFields,
                }))
            }