Finchie/l10n_embed - Change CESJ4CTO26X4GBZBPXRXLOJT3JQJOGFN5EJSNAAZELNQRZF7QSYAC

Move macro-specific code into `macro_impl` module

Should be a cleaner separation between macro code and fluent code, while keeping all the proc-macro logic in the same crate.

Created by finchie on July 31, 2024

CESJ4CTO26X4GBZBPXRXLOJT3JQJOGFN5EJSNAAZELNQRZF7QSYAC

Dependencies

In channels

main

Change contents

Replacement in fluent_embed_derive/tests/selectors.rs at line 6 [5.140]
B:BD[4.34] → [3.76:107]
```
use rstest::{fixture, rstest};
```
[4.34]
[5.340]
```
use rstest::rstest;
```
Deletion in fluent_embed_derive/tests/selectors.rs at line 42 [5.140]
B:BD[4.366] → [3.1191:1249]
```
    let expected_message = data.expected_message(locale);
```
File addition: macro_impl (d--x------)
[6.41]

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

[0.43]

use crate::fluent;
use icu_locid::locale;
use miette::Diagnostic;
use quote::quote;
use thiserror::Error;
mod attribute;
pub mod derive;
pub mod error;
#[derive(Diagnostic, Debug, Error)]
#[diagnostic(transparent)]
#[error(transparent)]
pub enum MacroError {
    Attribute(#[from] attribute::Error),
    #[error("invalid Fluent source code")]
    Fluent(#[from] fluent::Error),
}
pub fn localize(
    attribute: &syn::LitStr,
    derive_input: &syn::DeriveInput,
) -> Result<proc_macro2::TokenStream, MacroError> {
    let locales = attribute::locales(attribute)?;
    // TODO: user-controlled canonical locale
    let group = fluent::Group::new(locale!("en-US"), locales)?;
    let canonical_locale = group.canonical_locale().id.clone().to_string();
    let locales = match &derive_input.data {
        syn::Data::Struct(_struct_data) => derive::locales_for_ident(&group, &derive_input.ident),
        syn::Data::Enum(enum_data) => derive::locales_for_enum(&group, &enum_data.variants),
        syn::Data::Union(_) => todo!(),
    };
    let message_body = match &derive_input.data {
        syn::Data::Struct(struct_data) => {
            derive::message_for_struct(group, &derive_input.ident, &struct_data.fields)
        }
        syn::Data::Enum(enum_data) => derive::messages_for_enum(group, &enum_data.variants),
        syn::Data::Union(_) => todo!(),
    }?;
    let ident = &derive_input.ident;
    Ok(quote! {
        impl ::fluent_embed::Localize for #ident {
            const CANONICAL_LOCALE: ::fluent_embed::icu_locid::LanguageIdentifier =
                ::fluent_embed::icu_locid::langid!(#canonical_locale);
            fn message_for_locale(&self, locale: &::fluent_embed::icu_locid::LanguageIdentifier) -> String {
                #message_body
            }
            fn localize(&self) -> String {
                let available_locales = #locales;
                let selected_locale = ::fluent_embed::locale_select::match_locales(&available_locales, &Self::CANONICAL_LOCALE);
                self.message_for_locale(&selected_locale)
            }
        }
    })
}

File move: error.rs → error.rs
BF:BFD[6.41] → [7.952:984]
BF:BF[7.984] → [7.985:985]
[0.43]
[7.985]
Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 1 [7.985]
B:BD[7.985] → [7.986:1027]
```
use super::{AttributeError, MacroError};
```
[7.985]
[7.1027]
```
use super::{attribute, MacroError};
```

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

B:BD[7.1028] → [7.1028:1123]

use proc_macro_error::{abort, emit_call_site_error, emit_error};
use quote::{quote, ToTokens};

[7.1028]

[7.1123]

use proc_macro2::TokenStream;
use proc_macro_error::{emit_call_site_error, emit_error};
use syn::spanned::Spanned;

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

B:BD[7.1124] → [7.1124:1194]

fn attribute(error: AttributeError, derive_attribute: &syn::LitStr) {

[7.1124]

[7.1194]

fn attribute(error: attribute::Error, attribute_stream: TokenStream) {

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

B:BD[7.1212] → [7.1212:2324]

        AttributeError::Build(build_error) => {
            for location in build_error.locations() {
                // Create a token stream from the attribute's string literal
                let [proc_macro2::TokenTree::Literal(ref string_literal)] = derive_attribute
                    .to_token_stream()
                    .into_iter()
                    .collect::<Vec<_>>()[..]
                else {
                    abort!(derive_attribute, "unexpected macro attribute");
                };
                let (span_start, span_length) = location.span();
                let error_source = string_literal
                    // Offset by 1 to skip the starting `"` double-quote character
                    .subspan(span_start + 1..=span_start + span_length)
                    // Fall back to the whole attribute if `subspan()` returns `None`
                    // This will always happend on stable as subspan is nightly-only:
                    // https://docs.rs/proc-macro2/latest/proc_macro2/struct.Literal.html#method.subspan
                    .unwrap_or(derive_attribute.span());

[7.1212]

[7.2324]

        attribute::Error::Build(build_error) => {
            for located_error in build_error.locations() {
                let error_source = attribute_stream.span();

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

B:BD[7.2385] → [7.2385:2434]

                    note = location.to_string();

[7.2385]

[7.2434]

                    note = located_error.to_string();

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 18 [7.985]
B:BD[7.2477] → [7.2477:2523]
```
        AttributeError::Walk(walk_error) => {
```
[7.2477]
[7.2523]
```
        attribute::Error::Walk(walk_error) => {
```

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

B:BD[7.3134] → [7.3134:3238]

            emit_error! { derive_attribute, "error at depth {} while walking path", walk_error.depth();

[7.3134]

[7.3238]

            emit_error! { attribute_stream, "error at depth {} while walking path", walk_error.depth();

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 37 [7.985]
B:BD[7.3292] → [7.3292:3328]
```
        AttributeError::NoMatches {
```
[7.3292]
[7.3328]
```
        attribute::Error::NoMatches {
```

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

B:BD[7.3570] → [7.3570:3652]

            emit_error! { derive_attribute, "cannot match against an exact path";

[7.3570]

[7.3652]

            emit_error! { attribute_stream, "cannot match against an exact path";

Replacement in fluent_embed_derive/src/macro_impl/error.rs at line 55 [7.985]
B:BD[7.3961] → [7.3961:4002]
```
fn fluent(error: super::fluent::Error) {
```
[7.3961]
[7.4002]
```
fn fluent(error: crate::fluent::Error) {
```

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

B:BD[7.4667] → [7.4667:4797]

pub fn handle(
    error: MacroError,
    derive_attribute: &syn::LitStr,
    ident: &syn::Ident,
) -> proc_macro2::TokenStream {

[7.4667]

[7.4797]

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

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

B:BD[7.4815] → [7.4815:4891]

        MacroError::Attribute(error) => attribute(error, derive_attribute),

[7.4815]

[7.4891]

        MacroError::Attribute(error) => attribute(error, attribute_stream),

Deletion in fluent_embed_derive/src/macro_impl/error.rs at line 78 [7.985]

B:BD[7.4943] → [7.4943:5206]

    };
    // Generate a minimal `localize()` implementation so the error is self-contained
    quote! {
        impl #ident {
            fn localize(&self) -> String {
                unimplemented!("Encountered error in derive macro")
            }
        }

File move: derive.rs → derive.rs
BF:BFD[6.41] → [8.9150:9170]
BF:BF[8.9170] → [9.39:39]
[0.43]
[9.39]
Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 16 [9.39]
B:BD[8.9306] → [8.9306:9333]
```
pub struct DeriveContext {
```
[8.9306]
[8.9333]
```
pub struct Context {
```
Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 24 [9.39]
B:BD[10.178] → [8.9451:9487]
```
    reference_kind: &DeriveContext,
```
[10.178]
[8.9487]
```
    reference_kind: &Context,
```

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 87 [9.39]

B:BD[10.1236] → [8.9763:9823]

        syn::Fields::Named(named_fields) => DeriveContext {

[10.1236]

[10.1293]

        syn::Fields::Named(named_fields) => Context {

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 151 [9.39]

B:BD[10.1786] → [8.10104:10168]

            syn::Fields::Named(named_fields) => DeriveContext {

[10.1786]

[8.10168]

            syn::Fields::Named(named_fields) => Context {

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

[0.43]

use std::collections::HashMap;
use std::path::PathBuf;
use icu_locid::Locale;
use miette::Diagnostic;
use thiserror::Error;
use wax::walk::Entry;
#[derive(Diagnostic, Debug, Error)]
#[error(transparent)]
pub enum Error {
    Build(#[from] wax::BuildError),
    Walk(#[from] wax::walk::WalkError),
    #[error("Directory could not be matched by glob in macro attribute")]
    NoMatches {
        path: PathBuf,
        complete_match: String,
    },
}
pub fn locales(attribute: &syn::LitStr) -> Result<HashMap<Locale, PathBuf>, Error> {
    // Read the fluent file at the given path
    let manifest_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
    let attribute_glob = attribute.value();
    let mut locales = HashMap::new();
    let glob = wax::Glob::new(&attribute_glob)?;
    for potential_entry in glob.walk(&manifest_root) {
        // TODO: this assumes that the locale is the first capture
        let entry = potential_entry?;
        let captured_locale = if let Some(captured) = entry.matched().get(1) {
            captured
        } else {
            return Err(Error::NoMatches {
                path: entry.path().to_path_buf(),
                complete_match: entry.matched().complete().to_string(),
            });
        };
        // Captured directories may have a suffix of `/`
        let stripped_locale = captured_locale.strip_suffix('/').unwrap_or(captured_locale);
        // TODO: return an error instead of panic
        let locale = Locale::try_from_bytes(stripped_locale.as_bytes()).unwrap();
        // Insert this locale (and make sure it's unique!)
        let previous_value = locales.insert(locale, entry.into_path());
        assert!(previous_value.is_none());
    }
    Ok(locales)
}

Deletion in fluent_embed_derive/src/lib.rs at line 1 [6.74]
B:BD[11.4253] → [11.4253:4284]
B:BD[11.4284] → [12.0:24]
∅:D[12.24] → [11.4284:4318]
B:BD[11.4284] → [11.4284:4318]
B:BD[11.4318] → [10.6612:6636]
```
use std::collections::HashMap;
use std::path::PathBuf;
use icu_locid::{locale, Locale};
use miette::Diagnostic;
```
Deletion in fluent_embed_derive/src/lib.rs at line 5 [6.74]
∅:D[7.144] → [10.6637:6659]
B:BD[11.4388] → [10.6637:6659]
B:BD[10.6659] → [13.0:22]
```
use thiserror::Error;
use wax::walk::Entry;
```
Deletion in fluent_embed_derive/src/lib.rs at line 6 [6.74]
B:BD[11.4389] → [8.0:12]
B:BD[8.12] → [7.145:156]
```
mod derive;
mod error;
```

Replacement in fluent_embed_derive/src/lib.rs at line 7 [6.74]

∅:D[8.63] → [10.6718:6777]

B:BD[10.6718] → [10.6718:6777]

B:BD[10.6777] → [7.157:179]

∅:D[7.179] → [12.107:143]

B:BD[12.107] → [12.107:143]

B:BD[12.143] → [13.23:63]

∅:D[13.63] → [10.6778:6852]

B:BD[12.197] → [10.6778:6852]

∅:D[10.6852] → [12.216:294]

B:BD[12.216] → [12.216:294]

B:BD[12.294] → [10.6853:6941]

B:BD[10.6941] → [7.180:198]

∅:D[7.198] → [10.6963:7002]

B:BD[10.6963] → [10.6963:7002]

B:BD[10.7002] → [14.0:43]

B:BD[14.43] → [7.199:234]

∅:D[7.234] → [12.294:296]

∅:D[10.7079] → [12.294:296]

B:BD[12.294] → [12.294:296]

∅:D[12.296] → [15.1386:1387]

∅:D[16.912] → [15.1386:1387]

∅:D[9.1625] → [15.1386:1387]

∅:D[17.3486] → [15.1386:1387]

B:BD[15.1386] → [15.1386:1387]

B:BD[15.1387] → [7.235:262]

∅:D[7.262] → [8.95:180]

B:BD[8.95] → [8.95:180]

∅:D[18.87] → [11.4453:4569]

∅:D[8.180] → [11.4453:4569]

∅:D[12.384] → [11.4453:4569]

B:BD[11.4453] → [11.4453:4569]

B:BD[11.4569] → [8.181:225]

∅:D[8.225] → [11.4616:4617]

B:BD[11.4616] → [11.4616:4617]

B:BD[11.4617] → [8.226:264]

∅:D[8.264] → [11.4657:4658]

∅:D[10.7116] → [11.4657:4658]

B:BD[11.4657] → [11.4657:4658]

B:BD[11.4658] → [18.88:137]

∅:D[18.137] → [11.4715:4837]

B:BD[11.4715] → [11.4715:4837]

B:BD[11.4837] → [18.138:176]

B:BD[18.176] → [10.7117:7118]

∅:D[10.7118] → [12.385:702]

B:BD[18.176] → [12.385:702]

∅:D[12.702] → [11.4946:5096]

B:BD[11.4946] → [11.4946:5096]

B:BD[11.5096] → [14.44:94]

∅:D[14.94] → [11.5096:5179]

B:BD[11.5096] → [11.5096:5179]

B:BD[11.5179] → [8.265:439]

∅:D[8.439] → [11.5421:5428]

∅:D[10.7240] → [11.5421:5428]

B:BD[11.5421] → [11.5421:5428]

B:BD[11.5428] → [8.440:456]

∅:D[18.225] → [11.5472:5475]

∅:D[8.456] → [11.5472:5475]

∅:D[10.7296] → [11.5472:5475]

B:BD[11.5472] → [11.5472:5475]

B:BD[11.5475] → [7.263:281]

∅:D[7.281] → [8.474:540]

B:BD[8.474] → [8.474:540]

B:BD[8.540] → [7.282:388]

∅:D[7.388] → [8.664:774]

B:BD[8.664] → [8.664:774]

B:BD[8.774] → [19.1308:1384]

B:BD[19.1384] → [2.0:285]


#[derive(Diagnostic, Debug, Error)]
#[error(transparent)]
enum AttributeError {
    Build(#[from] wax::BuildError),
    Walk(#[from] wax::walk::WalkError),
    #[error("Directory could not be matched by glob in macro attribute")]
    NoMatches {
        path: PathBuf,
        complete_match: String,
    },
}
#[derive(Diagnostic, Debug, Error)]
#[diagnostic(transparent)]
#[error(transparent)]
enum MacroError {
    Attribute(#[from] AttributeError),
    #[error("invalid Fluent source code")]
    Fluent(#[from] fluent::Error),
}
fn locales_from_attribute(
    attribute: &syn::LitStr,
) -> Result<HashMap<Locale, PathBuf>, AttributeError> {
    // Read the fluent file at the given path
    let manifest_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
    let attribute_glob = attribute.value();
    let mut locales = HashMap::new();
    let glob = wax::Glob::new(&attribute_glob)?;
    for potential_entry in glob.walk(&manifest_root) {
        // TODO: this assumes that the locale is the first capture
        let entry = potential_entry?;
        let captured_locale = if let Some(captured) = entry.matched().get(1) {
            captured
        } else {
            return Err(AttributeError::NoMatches {
                path: entry.path().to_path_buf(),
                complete_match: entry.matched().complete().to_string(),
            });
        };
        // Captured directories may have a suffix of `/`
        let stripped_locale = captured_locale.strip_suffix('/').unwrap_or(captured_locale);
        // TODO: return an error instead of panic
        let locale = Locale::try_from_bytes(stripped_locale.as_bytes()).unwrap();
        // Insert this locale (and make sure it's unique!)
        let previous_value = locales.insert(locale, entry.into_path());
        assert!(previous_value.is_none());
    }
    Ok(locales)
}
fn localize_impl(
    attribute: &syn::LitStr,
    derive_input: &syn::DeriveInput,
) -> Result<proc_macro2::TokenStream, MacroError> {
    let locales = locales_from_attribute(attribute)?;
    // TODO: user-controlled canonical locale
    let group = fluent::Group::new(locale!("en-US"), locales)?;
    let canonical_locale = group.canonical_locale().id.clone().to_string();
    let locales = match &derive_input.data {
        syn::Data::Struct(_struct_data) => derive::locales_for_ident(&group, &derive_input.ident),
        syn::Data::Enum(enum_data) => derive::locales_for_enum(&group, &enum_data.variants),
        syn::Data::Union(_) => todo!(),
    };

[8.24]

[11.5596]

mod macro_impl;

Deletion in fluent_embed_derive/src/lib.rs at line 9 [6.74]

B:BD[11.5597] → [2.286:336]

∅:D[2.336] → [10.7399:7443]

B:BD[11.5639] → [10.7399:7443]

B:BD[10.7443] → [2.337:425]

∅:D[2.425] → [10.7531:7541]

∅:D[8.855] → [10.7531:7541]

B:BD[10.7531] → [10.7531:7541]

B:BD[10.7541] → [2.426:519]

∅:D[2.519] → [11.5830:5870]

∅:D[8.940] → [11.5830:5870]

B:BD[11.5830] → [11.5830:5870]

B:BD[11.5870] → [10.7542:7550]

∅:D[10.7550] → [11.5877:5915]

B:BD[11.5877] → [11.5877:5915]

B:BD[11.5915] → [19.1385:1386]

∅:D[19.1386] → [18.384:400]

B:BD[11.5915] → [18.384:400]

B:BD[18.400] → [20.62:268]

B:BD[20.268] → [2.520:675]

∅:D[20.268] → [11.6021:6064]

∅:D[2.675] → [11.6021:6064]

∅:D[19.1617] → [11.6021:6064]

B:BD[11.6021] → [11.6021:6064]

B:BD[11.6064] → [2.676:914]

∅:D[2.914] → [11.6086:6110]

B:BD[11.6086] → [11.6086:6110]

B:BD[11.6110] → [18.401:408]

∅:D[18.408] → [11.6116:6118]

B:BD[11.6116] → [11.6116:6118]

B:BD[11.6118] → [7.389:390]

    let message_body = match &derive_input.data {
        syn::Data::Struct(struct_data) => {
            derive::message_for_struct(group, &derive_input.ident, &struct_data.fields)
        }
        syn::Data::Enum(enum_data) => derive::messages_for_enum(group, &enum_data.variants),
        syn::Data::Union(_) => todo!(),
    }?;
    let ident = &derive_input.ident;
    Ok(quote! {
        impl ::fluent_embed::Localize for #ident {
            const CANONICAL_LOCALE: ::fluent_embed::icu_locid::LanguageIdentifier =
                ::fluent_embed::icu_locid::langid!(#canonical_locale);
            fn message_for_locale(&self, locale: &::fluent_embed::icu_locid::LanguageIdentifier) -> String {
                #message_body
            }
            fn localize(&self) -> String {
                let available_locales = #locales;
                let selected_locale = ::fluent_embed::locale_select::match_locales(&available_locales, &Self::CANONICAL_LOCALE);
                self.message_for_locale(&selected_locale)
            }
        }
    })
}

Insertion in fluent_embed_derive/src/lib.rs at line 13 [6.74]

[7.580]

    let attribute_stream = proc_macro2::TokenStream::from(attribute.clone());

Replacement in fluent_embed_derive/src/lib.rs at line 17 [6.74]

B:BD[7.701] → [7.701:869]

    let implementation = localize_impl(&derive_attribute, &derive_input)
        .unwrap_or_else(|error| error::handle(error, &derive_attribute, &derive_input.ident));

[7.701]

[7.869]

    match macro_impl::localize(&derive_attribute, &derive_input) {
        Ok(implementation) => {
            // No errors found, emit the generated `fluent_embed::Localize` implementation
            quote! {
                #original_item

Replacement in fluent_embed_derive/src/lib.rs at line 23 [6.74]

B:BD[7.870] → [7.870:906]

    quote! {
        #original_item

[7.870]

[7.906]

                #implementation
            }
        }
        Err(error) => {
            // Emit the relevant error message
            macro_impl::error::emit(error, attribute_stream);

Replacement in fluent_embed_derive/src/lib.rs at line 30 [6.74]

B:BD[7.907] → [7.907:931]

        #implementation

[7.907]

[7.931]

            // Generate a minimal `localize()` implementation so the error is self-contained
            let ident = derive_input.ident;
            quote! {
                impl #ident {
                    fn localize(&self) -> String {
                        unimplemented!("Encountered error in derive macro")
                    }
                }
            }
        }

Replacement in fluent_embed_derive/src/fluent/mod.rs at line 1 [8.992]
B:BD[8.992] → [8.993:1027]
```
use crate::derive::DeriveContext;
```
[8.992]
[8.1027]
```
use crate::macro_impl::derive;
```
Replacement in fluent_embed_derive/src/fluent/mod.rs at line 66 [8.992]
B:BD[8.1571] → [8.1571:1616]
```
    derive_context: &'context DeriveContext,
```
[8.1546]
[8.1616]
```
    derive_context: &'context derive::Context,
```
Replacement in fluent_embed_derive/src/fluent/mod.rs at line 179 [8.992]
B:BD[8.3326] → [8.3326:3366]
```
        derive_context: &DeriveContext,
```
[8.3326]
[8.3366]
```
        derive_context: &derive::Context,
```
Replacement in fluent_embed_derive/src/fluent/group.rs at line 2 [17.3543]
B:BD[8.4042] → [8.4042:4076]
```
use crate::derive::DeriveContext;
```
[8.4042]
[14.3940]
```
use crate::macro_impl::derive;
```
Replacement in fluent_embed_derive/src/fluent/group.rs at line 80 [17.3543]
B:BD[10.7895] → [8.5281:5321]
```
        derive_context: &DeriveContext,
```
[10.7895]
[8.5321]
```
        derive_context: &derive::Context,
```
Replacement in fluent_embed_derive/src/fluent/group.rs at line 91 [17.3543]
B:BD[11.6789] → [8.5607:5647]
```
        derive_context: &DeriveContext,
```
[11.6789]
[8.5647]
```
        derive_context: &derive::Context,
```
Replacement in fluent_embed_derive/src/fluent/ast.rs at line 2 [17.33]
B:BD[8.6447] → [8.6447:6481]
```
use crate::derive::ReferenceKind;
```
[8.6447]
[10.2216]
```
use crate::macro_impl::derive::ReferenceKind;
```

Move macro-specific code into `macro_impl` module

Dependencies

In channels

Change contents

Replacement in fluent_embed_derive/tests/selectors.rs at line 6 [5.140]

Deletion in fluent_embed_derive/tests/selectors.rs at line 42 [5.140]

File addition: macro_impl (d--x------)

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

File move: error.rs → error.rs

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

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

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

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

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

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

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

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

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

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

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

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

Deletion in fluent_embed_derive/src/macro_impl/error.rs at line 78 [7.985]

File move: derive.rs → derive.rs

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 16 [9.39]

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 24 [9.39]

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 87 [9.39]

Replacement in fluent_embed_derive/src/macro_impl/derive.rs at line 151 [9.39]

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

Deletion in fluent_embed_derive/src/lib.rs at line 1 [6.74]

Deletion in fluent_embed_derive/src/lib.rs at line 5 [6.74]

Deletion in fluent_embed_derive/src/lib.rs at line 6 [6.74]

Replacement in fluent_embed_derive/src/lib.rs at line 7 [6.74]

Deletion in fluent_embed_derive/src/lib.rs at line 9 [6.74]

Insertion in fluent_embed_derive/src/lib.rs at line 13 [6.74]

Replacement in fluent_embed_derive/src/lib.rs at line 17 [6.74]

Replacement in fluent_embed_derive/src/lib.rs at line 23 [6.74]

Replacement in fluent_embed_derive/src/lib.rs at line 30 [6.74]

Replacement in fluent_embed_derive/src/fluent/mod.rs at line 1 [8.992]

Replacement in fluent_embed_derive/src/fluent/mod.rs at line 66 [8.992]

Replacement in fluent_embed_derive/src/fluent/mod.rs at line 179 [8.992]

Replacement in fluent_embed_derive/src/fluent/group.rs at line 2 [17.3543]

Replacement in fluent_embed_derive/src/fluent/group.rs at line 80 [17.3543]

Replacement in fluent_embed_derive/src/fluent/group.rs at line 91 [17.3543]

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 2 [17.33]