Finchie/l10n_embed - Change TFKGE6LRNSG2N5Z3LIITYG7WH2VOLWQO7AESTWRWV52BFHESU26AC

Emit shim implementation on macro error

This uses proc_macro_error2::set_dummy to correctly return the derive input stream and a shim implementation (if possible) when encountering an error, as opposed to the previous implementation which would generate the shim but never return the token stream, leading to the derive input getting consumed by the macro and causing unnecessary errors.

Created by finchie on September 8, 2025

TFKGE6LRNSG2N5Z3LIITYG7WH2VOLWQO7AESTWRWV52BFHESU26AC

Dependencies

In channels

main

Change contents

Deletion in l10n_embed_derive/src/lib.rs at line 16 [13.74]
B:BD[3.5274] → [10.1870:1959]
∅:D[10.1959] → [9.1709:1710]
B:BD[3.5365] → [9.1709:1710]
```
            // No errors found, emit the generated `l10n_embed::Localize` implementation
```

Replacement in l10n_embed_derive/src/lib.rs at line 33 [13.74]

B:BD[3.5498] → [3.5498:5545]

B:BD[3.5545] → [8.1243:1328]

            // Emit the relevant error message
            macro_impl::error::emit(error, &attribute_stream, &derive_input_stream);

[3.5498]

[2.906]

            // Using the `proc_macro_error2` crate to generate errors ignores
            // the token stream returned from this function, so use the `set_dummy` function
            // to make sure a macro error is as self-contained as possible:
            // - Derive input streams are not consumed, so structs/enums don't "disappear" when macro returns error
            // - Generate a shim trait implementation when possible so that editor completions still work as expected
            proc_macro_error2::set_dummy(
                match syn::parse2::<syn::DeriveInput>(derive_input_stream.clone()) {
                    // Generate a minimal `Localize` implementation so the error is self-contained
                    Ok(derive_input) => {
                        let ident = derive_input.ident;
                        let (impl_generics, type_generics, where_clause) =
                            derive_input.generics.split_for_impl();

Replacement in l10n_embed_derive/src/lib.rs at line 46 [13.74]

B:BD[2.907] → [4.0:91]

B:BD[4.91] → [5.2117:2362]

            // Generate a minimal `Localize` implementation so the error is self-contained
            match syn::parse2::<syn::DeriveInput>(derive_input_stream.clone()) {
                Ok(derive_input) => {
                    let ident = derive_input.ident;
                    quote! {
                        #derive_input_stream

[2.907]

[9.1794]

                        quote! {
                            #derive_input_stream

Replacement in l10n_embed_derive/src/lib.rs at line 49 [13.74]

B:BD[9.1795] → [10.2022:2087]

B:BD[10.2087] → [12.4287:4328]

∅:D[6.476] → [5.2937:2976]

∅:D[11.745] → [5.2937:2976]

∅:D[7.1403] → [5.2937:2976]

∅:D[12.4328] → [5.2937:2976]

B:BD[5.2937] → [5.2937:2976]

B:BD[5.2976] → [12.4329:4479]

∅:D[7.1446] → [5.3194:3278]

∅:D[12.4479] → [5.3194:3278]

B:BD[5.3194] → [5.3194:3278]

                        impl ::l10n_embed::Localize for #ident {
                            fn localize(
                                &self,
                                context: &::l10n_embed::Context,
                                buffer: &mut String,
                            ) {
                                unimplemented!("Encountered error in derive macro")

[9.1795]

[5.3278]

                            impl #impl_generics ::l10n_embed::Localize for #ident #type_generics #where_clause {
                                fn localize(
                                    &self,
                                    context: &::l10n_embed::Context,
                                    buffer: &mut String,
                                ) {
                                    unimplemented!("Encountered error in derive macro")
                                }

Replacement in l10n_embed_derive/src/lib.rs at line 60 [13.74]

B:BD[3.5945] → [9.1874:1892]

∅:D[9.1892] → [5.3354:3505]

B:BD[5.3354] → [5.3354:3505]

∅:D[5.3505] → [3.5963:5977]

B:BD[3.5963] → [3.5963:5977]

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

[3.5945]

[3.5977]

                    // Unable to implement Localize if the ident is unknown, so just return the original input
                    Err(_) => derive_input_stream.clone(),
                },
            );
            // Emit the relevant error message
            macro_impl::error::emit(error, &attribute_stream, &derive_input_stream);
            // `proc_macro_error2` will output the relevant token stream, but the function still needs to return something
            quote!()