finchie/l10n_embed - Change 7JPOCQEISAIOD7LV4JYBE6NNUWUKKNE73MEPQYTIZ7PP44ZAD2RAC

Add explicit error handling for macro parsing

The error messages are not much better than before, but now at least give a hint of where to go next. Since it is now using the common error handling code, it should be much easier to improve going forward.

Created by finchie on April 15, 2025

7JPOCQEISAIOD7LV4JYBE6NNUWUKKNE73MEPQYTIZ7PP44ZAD2RAC

Dependencies

In channels

main

Change contents

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

[3.320]

[4.295]

#[error("Failed to parse macro input")]
pub enum ParseError {
    #[error("invalid attribute")]
    InvalidAttribute(syn::Error),
    #[error("invalid item")]
    InvalidDeriveInput(syn::Error),
}
#[derive(Debug, Error)]

Insertion in fluent_embed_derive/src/macro_impl/mod.rs at line 42 [4.76]
[3.364]
[4.458]
```
    ParseError(#[from] ParseError),
```

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

B:BD[4.478] → [4.478:544]

    attribute: &syn::LitStr,
    derive_input: &syn::DeriveInput,

[4.478]

[4.544]

    attribute_stream: proc_macro2::TokenStream,
    derive_input_stream: proc_macro2::TokenStream,

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

∅:D[5.360] → [4.596:646]

B:BD[4.596] → [4.596:646]

    let locales = attribute::locales(attribute)?;

[5.360]

[6.0]

    // Parse the token streams
    let attribute: syn::LitStr = syn::parse2(attribute_stream)
        .map_err(|parse_error| ParseError::InvalidAttribute(parse_error))?;
    let derive_input: syn::DeriveInput = syn::parse2(derive_input_stream)
        .map_err(|parse_error| ParseError::InvalidDeriveInput(parse_error))?;
    let locales = attribute::locales(&attribute)?;

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 4 [7.985]

B:BD[3.1562] → [3.1562:1615]

    MacroError, UnsupportedError, UnsupportedReason,

[3.1562]

[3.1615]

    MacroError, ParseError, UnsupportedError, UnsupportedReason,

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 115 [7.985]

B:BD[3.2111] → [3.2111:2207]

                note = "There must be at least one named field (unit structs are unsupported!)"

[3.2111]

[3.2207]

                note = "There must be at least one named field (unit structs are unsupported!)";
            }
        }
    }
}
fn parse(error: ParseError, attribute_stream: TokenStream, derive_input_stream: TokenStream) {
    match error {
        ParseError::InvalidAttribute(invalid_attribute) => {
            emit_error! { attribute_stream, invalid_attribute;
                help = "Expected a path glob, for example {}",
                r#"#[localize("i18n/**/strings.ftl")]"#;
            }
        }
        ParseError::InvalidDeriveInput(invalid_derive_input) => {
            emit_error! { derive_input_stream, invalid_derive_input;
                help = "This macro can only be used on structs or enums";

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 137 [7.985]

B:BD[7.4667] → [4.2971:3035]

pub fn emit(error: MacroError, attribute_stream: TokenStream) {

[7.4667]

[7.4797]

pub fn emit(error: MacroError, attribute_stream: TokenStream, derive_input_stream: TokenStream) {

Insertion in fluent_embed_derive/src/macro_impl/error.rs at line 142 [7.985]

[3.2294]

[7.5206]

        MacroError::ParseError(error) => parse(error, attribute_stream, derive_input_stream),

Replacement in fluent_embed_derive/src/lib.rs at line 2 [8.74]
B:BD[7.75] → [7.75:115]
```
use proc_macro_error::proc_macro_error;
```
[7.75]
[9.4348]
```
use proc_macro_error::{proc_macro_error};
```
Deletion in fluent_embed_derive/src/lib.rs at line 4 [8.74]
B:BD[9.4366] → [7.116:144]
```
use syn::parse_macro_input;
```

Replacement in fluent_embed_derive/src/lib.rs at line 11 [8.74]

B:BD[7.510] → [7.510:580]

B:BD[7.580] → [4.5096:5174]

∅:D[4.5174] → [7.580:700]

B:BD[7.580] → [7.580:700]

    let original_item = proc_macro2::TokenStream::from(item.clone());
    let attribute_stream = proc_macro2::TokenStream::from(attribute.clone());
    let derive_attribute: syn::LitStr = parse_macro_input!(attribute);
    let derive_input = parse_macro_input!(item);

[7.510]

[7.700]

    let attribute_stream = proc_macro2::TokenStream::from(attribute);
    let derive_input_stream = proc_macro2::TokenStream::from(item);

Replacement in fluent_embed_derive/src/lib.rs at line 14 [8.74]

B:BD[7.701] → [4.5175:5242]

    match macro_impl::localize(&derive_attribute, &derive_input) {

[7.701]

[4.5242]

    match macro_impl::localize(attribute_stream.clone(), derive_input_stream.clone()) {

Replacement in fluent_embed_derive/src/lib.rs at line 19 [8.74]
B:BD[10.3498] → [11.789:819]
```
                #derive_input
```
[10.3498]
[7.869]
```
                #derive_input_stream
```

Replacement in fluent_embed_derive/src/lib.rs at line 36 [8.74]

B:BD[4.5545] → [4.5545:5607]

            macro_impl::error::emit(error, attribute_stream);

[4.5545]

[7.906]

            macro_impl::error::emit(error, attribute_stream, derive_input_stream.clone());

Replacement in fluent_embed_derive/src/lib.rs at line 39 [8.74]

∅:D[2.91] → [4.5701:5766]

B:BD[4.5701] → [4.5701:5766]

B:BD[4.5766] → [2.92:574]

            let ident = derive_input.ident;
            quote! {
                #original_item
                impl<W: ::std::io::Write> ::fluent_embed::Localize<W> for #ident {
                    const CANONICAL_LOCALE: ::fluent_embed::icu_locale::LanguageIdentifier =
                        ::fluent_embed::icu_locale::langid!("en-US");
                    fn available_locales(&self) -> Vec<::fluent_embed::icu_locale::LanguageIdentifier> {
                        unimplemented!("Encountered error in derive macro")
                    }

[2.91]

[2.574]

            match syn::parse2::<syn::DeriveInput>(derive_input_stream.clone()) {
                Ok(derive_input) => {
                    let ident = derive_input.ident;
                    quote! {
                        #derive_input_stream
        
                        impl<W: ::std::io::Write> ::fluent_embed::Localize<W> for #ident {
                            const CANONICAL_LOCALE: ::fluent_embed::icu_locale::LanguageIdentifier =
                                ::fluent_embed::icu_locale::langid!("en-US");

Replacement in fluent_embed_derive/src/lib.rs at line 49 [8.74]

B:BD[2.583] → [2.583:851]

∅:D[2.851] → [4.5847:5923]

B:BD[4.5847] → [4.5847:5923]

                    fn message_for_locale(
                        &self,
                        writer: &mut W,
                        locale: &::fluent_embed::icu_locale::LanguageIdentifier,
                    ) -> Result<(), ::fluent_embed::LocalizationError> {
                        unimplemented!("Encountered error in derive macro")

[2.583]

[4.5923]

                            fn available_locales(&self) -> Vec<::fluent_embed::icu_locale::LanguageIdentifier> {
                                unimplemented!("Encountered error in derive macro")
                            }
                
                            fn message_for_locale(
                                &self,
                                writer: &mut W,
                                locale: &::fluent_embed::icu_locale::LanguageIdentifier,
                            ) -> Result<(), ::fluent_embed::LocalizationError> {
                                unimplemented!("Encountered error in derive macro")
                            }
                        }

Replacement in fluent_embed_derive/src/lib.rs at line 62 [8.74]

B:BD[4.5945] → [4.5945:5963]

[4.5945]

[4.5963]

                },
                // Unable to fail gracefully if the ident is unknown, so just return the original input
                Err(_) => derive_input_stream,

Insertion in fluent_embed_derive/src/lib.rs at line 66 [8.74]
[4.5977]
[4.5977]
```
            
```