Finchie/l10n_embed - Change 3NMKD6I57ONAGHEN4PZIAV2KPYESVR4JL3DTWSHXKCMVJBEQ4GIQC

Refactor `Localize` trait to use `std::io::Write`

Most of the changes are "noise" - the refactor touched most parts of the codebase. The main change is that instead of returning the output of format!, the generated code now calls writer.write_all() and returns an empty Ok(()) on success. This should make things a bit cleaner and hopefully reduce the amount of unncecessary allocation at compile-time.

Created by finchie on August 26, 2024

3NMKD6I57ONAGHEN4PZIAV2KPYESVR4JL3DTWSHXKCMVJBEQ4GIQC

Dependencies

In channels

main

Change contents

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

B:BD[4.1450] → [4.1450:1523]

    assert_eq!(data.message_for_locale(&language_id), expected_message);

[4.1450]

[5.1111]

    let mut buffer = Vec::new();
    data.message_for_locale(&mut buffer, &language_id);
    assert_eq!(String::from_utf8(buffer), Ok(expected_message));

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 31 [2.76]
B:BD[2.834] → [2.834:879]
```
    let locales = match &derive_input.data {
```
[2.834]
[2.879]
```
    let available_locales = match &derive_input.data {
```

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 48 [2.76]

B:BD[2.1507] → [2.1507:1558]

        impl ::fluent_embed::Localize for #ident {

[2.1507]

[2.1558]

        impl<W: ::std::io::Write> ::fluent_embed::Localize<W> for #ident {

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 52 [2.76]

B:BD[2.1714] → [2.1714:1853]

            fn message_for_locale(&self, locale: &::fluent_embed::icu_locid::LanguageIdentifier) -> String {
                #message_body

[2.1714]

[2.1853]

            fn available_locales(&self) -> Vec<::fluent_embed::icu_locid::LanguageIdentifier> {
                #available_locales

Replacement in fluent_embed_derive/src/macro_impl/mod.rs at line 56 [2.76]

B:BD[2.1868] → [2.1868:2149]

            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)

[2.1868]

[2.2149]

            fn message_for_locale(
                &self,
                writer: &mut W,
                locale: &::fluent_embed::icu_locid::LanguageIdentifier,
            ) -> Result<(), ::fluent_embed::LocalizationError> {
                #message_body

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

∅:D[6.2509] → [7.1181:1275]

B:BD[9.713] → [7.1181:1275]

        #(if locale.normalizing_eq(#additional_locales) { return #additional_messages })else*

[6.2509]

[6.2510]

        #(if locale.normalizing_eq(#additional_locales) {
            #additional_messages
            return Ok(());
        }) else*

Insertion in fluent_embed_derive/src/macro_impl/derive.rs at line 52 [8.39]
[7.1302]
[10.511]
```
        Ok(())
```
Insertion in fluent_embed_derive/src/fluent/ast.rs at line 1 [11.33]
[11.33]
[12.6411]
```
use std::cell::OnceCell;
```
Replacement in fluent_embed_derive/src/fluent/ast.rs at line 13 [11.33]
∅:D[13.120] → [11.352:436]
∅:D[14.283] → [11.352:436]
∅:D[7.3123] → [11.352:436]
∅:D[10.3166] → [11.352:436]
∅:D[12.6657] → [11.352:436]
B:BD[11.352] → [11.352:436]
```
    let mut format_body = String::new();
    let mut format_arguments = Vec::new();
```
[12.6657]
[11.436]
```
    let mut write_expressions: Vec<syn::Expr> =
        Vec::with_capacity(message_context.pattern.elements.len());
```

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 18 [11.33]

B:BD[11.500] → [11.500:582]

            PatternElement::TextElement { value } => format_body.push_str(value),

[11.500]

[11.582]

            PatternElement::TextElement { value } => {
                let byte_string_literal = proc_macro2::Literal::byte_string(value.as_bytes());
                write_expressions.push(parse_quote!(writer.write_all(#byte_string_literal)?));
            }

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 23 [11.33]

B:BD[11.640] → [10.3167:3219]

                let expression = match expression {

[11.640]

[10.3219]

                write_expressions.push(match expression {

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 25 [11.33]

B:BD[10.3286] → [12.6714:6888]

                        let target = inline_expression(selector, message_context)?;
                        let mut arms: Vec<syn::Arm> = Vec::with_capacity(variants.len());

[10.3286]

[12.6888]

                        let match_target = inline_expression(selector, message_context)?;
                        let default_arm = OnceCell::new();
                        let mut additional_arms = Vec::with_capacity(variants.len());

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 30 [11.33]

B:BD[12.6939] → [12.6939:7017]

                            let base_pattern: syn::Pat = match &variant.key {

[12.6939]

[12.7017]

                            let variant_pattern: syn::Pat = match &variant.key {

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 32 [11.33]

B:BD[12.7086] → [12.7086:7178]

B:BD[12.7178] → [15.269:371]

                                    let ident = format_ident!("{}", name.to_pascal_case());
                                    parse_quote!(::fluent_embed::icu_plurals::PluralCategory::#ident)

[12.7086]

[12.7266]

                                    let ident_pascal_case =
                                        format_ident!("{}", name.to_pascal_case());
                                    parse_quote!(::fluent_embed::icu_plurals::PluralCategory::#ident_pascal_case)

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 38 [11.33]

B:BD[12.7408] → [12.7408:7486]

                            // Create a new `MessageContext` for each variant

[12.7408]

[12.7486]


                            // Create a new `MessageContext` for each variant body

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 44 [11.33]

B:BD[12.7691] → [12.7691:7762]

                            let body = message_body(variant_context)?;

[12.7691]

[12.7762]

                            let variant_body = message_body(variant_context)?;
                            // The default pattern must go last so we don't generate invalid match stataments

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 48 [11.33]

B:BD[12.7763] → [12.7763:8138]

                            // Default patterns match anything else
                            // TODO: this can potentially generate unreachable patterns,
                            // should be replaced with a more sophisticated implementation
                            let pattern = if variant.default {
                                parse_quote!(#base_pattern | _)

[12.7763]

[12.8138]

                            if variant.default {
                                default_arm
                                    .set(quote!(#variant_pattern | _ => #variant_body))
                                    .expect("Multiple default patterns for match statement.");

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 53 [11.33]

B:BD[12.8175] → [12.8175:8251]

                                base_pattern
                            };

[12.8175]

[10.3624]

                                additional_arms.push(quote!(#variant_pattern => #variant_body));
                            }
                        }

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 57 [11.33]

B:BD[10.3625] → [12.8252:8350]

                            arms.push(parse_quote!(#pattern => #body));
                        }

[10.3625]

[12.8350]

                        // TODO: handle this as an error
                        let default_arm = default_arm.get().unwrap();

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 61 [11.33]

B:BD[10.3664] → [10.3664:3778]

                            match plural_rules.category_for(#target) {
                                #(#arms),*

[10.3664]

[10.3778]

                            match plural_rules.category_for(#match_target) {
                                #(#additional_arms,)*
                                #default_arm,

Deletion in fluent_embed_derive/src/fluent/ast.rs at line 65 [11.33]
B:BD[10.3808] → [10.3808:3809]

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 68 [11.33]

B:BD[10.3913] → [12.8352:8424]

                        inline_expression(expression, message_context)?

[10.3913]

[10.3995]

                        let expression = inline_expression(expression, message_context)?;
                        parse_quote!(writer.write_all(#expression)?)

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 71 [11.33]
B:BD[10.4017] → [10.4017:4036]
∅:D[13.189] → [11.714:818]
∅:D[7.3208] → [11.714:818]
∅:D[10.4036] → [11.714:818]
B:BD[11.714] → [11.714:818]
```
                };
                format_body.push_str("{}");
                format_arguments.push(quote!(#expression));
```
[10.4017]
[11.818]
```
                });
```

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 76 [11.33]

B:BD[11.849] → [11.849:943]

B:BD[11.1018] → [11.1018:1019]

B:BD[11.1019] → [10.4037:4127]

    let format_body_literal = proc_macro2::Literal::string(format_body.to_string().as_str());
    Ok(parse_quote!(
        format!(#format_body_literal, #(#format_arguments),*)
    ))

[11.849]

[11.1626]

    Ok(parse_quote! {
        {
            #(#write_expressions;)*
        }
    })

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 89 [11.33]

B:BD[11.1824] → [11.1824:1936]

            let string_literal = proc_macro2::Literal::string(value);
            parse_quote!(#string_literal)

[11.1824]

[11.1936]

            let byte_string_literal = proc_macro2::Literal::byte_string(value.as_bytes());
            parse_quote!(#byte_string_literal)

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 101 [11.33]

B:BD[10.4416] → [10.4416:4489]

            // let ident = format_ident!("{}", id.name.to_snake_case());

[10.4416]

[12.8495]

            let fluent_name = &id.name;
            let rust_name = id.name.to_snake_case();

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 107 [11.33]
B:BD[12.8625] → [12.8625:8672]
```
                .get(&id.name.to_snake_case())
```
[12.8625]
[10.4589]
```
                .get(&rust_name)
```

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 116 [11.33]

B:BD[16.5925] → [16.5925:5977]

                    .find(&format!("${}", id.name))

[16.5925]

[16.5977]

                    .find(&format!("${fluent_name}"))

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 121 [11.33]

B:BD[16.6091] → [16.6091:6197]

                    fluent_name: id.name.clone(),
                    rust_name: id.name.to_snake_case(),

[16.6091]

[16.6197]

                    fluent_name: fluent_name.clone(),
                    rust_name,

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 124 [11.33]

B:BD[16.6230] → [16.6230:6305]

                    span: SourceSpan::new(location.into(), id.name.len()),

[16.6230]

[16.6305]

                    span: SourceSpan::new(location.into(), fluent_name.len()),

Replacement in fluent_embed_derive/src/fluent/ast.rs at line 140 [11.33]

B:BD[7.3850] → [7.3850:3923]

                ReferenceKind::StructField => parse_quote!(self.#ident),

[7.3850]

[7.3923]

                ReferenceKind::StructField => parse_quote!(message_context.#ident),

Replacement in fluent_embed/src/time.rs at line 1 [17.53]
B:BD[17.53] → [3.0:21]
```
use crate::Localize;
```
[17.53]
[3.21]
```
use crate::{LocalizationError, Localize};
```
Insertion in fluent_embed/src/time.rs at line 10 [17.53]
[17.350]
[17.350]
```
use writeable::Writeable;
```

Deletion in fluent_embed/src/time.rs at line 16 [17.53]

B:BD[17.550] → [17.550:647]


/// The locale to fall back to
pub const DEFAULT_LOCALE: LanguageIdentifier = langid!("en-US");

Replacement in fluent_embed/src/time.rs at line 26 [17.53]

B:BD[17.955] → [3.26:124]

impl Localize for RelativeTime {
    const CANONICAL_LOCALE: LanguageIdentifier = DEFAULT_LOCALE;

[17.955]

[3.124]

impl<W: std::io::Write> Localize<W> for RelativeTime {
    const CANONICAL_LOCALE: LanguageIdentifier = langid!("en-US");
    fn available_locales(&self) -> Vec<LanguageIdentifier> {
        // TODO: keep track of all locales with Fluent data, and return only those
        vec![<Self as Localize<W>>::CANONICAL_LOCALE]
    }

Replacement in fluent_embed/src/time.rs at line 34 [17.53]

B:BD[3.125] → [3.125:199]

    fn message_for_locale(&self, locale: &LanguageIdentifier) -> String {

[3.125]

[17.990]

    fn message_for_locale(
        &self,
        writer: &mut W,
        locale: &LanguageIdentifier,
    ) -> Result<(), LocalizationError> {

Replacement in fluent_embed/src/time.rs at line 112 [17.53]

B:BD[17.4306] → [17.4306:4358]

        formatter.format(decimal).to_string()
    }

[17.4306]

[3.249]

        let formatted_text = formatter.format(decimal);
        writer.write_all(formatted_text.write_to_string().as_bytes())?;
        writer.flush()?;

Replacement in fluent_embed/src/time.rs at line 117 [17.53]

B:BD[3.250] → [3.250:394]

    fn localize(&self) -> String {
        // TODO: select locale based on environment
        self.message_for_locale(&Self::CANONICAL_LOCALE)

[3.250]

[3.394]

        Ok(())

Replacement in fluent_embed/src/lib.rs at line 14 [6.82]

B:BD[6.406] → [6.406:427]

pub trait Localize {

[6.406]

[6.427]

#[derive(thiserror::Error, Debug)]
pub enum LocalizationError {
    #[error("invalid locale selected")]
    InvalidLocale,
    #[error("unable to write localized output")]
    IO(#[from] std::io::Error),
}
pub trait Localize<W: std::io::Write> {
    // TODO: this should be project-wide and tracked at build time

Replacement in fluent_embed/src/lib.rs at line 26 [6.82]

B:BD[6.512] → [18.2853:2960]

    fn message_for_locale(&self, locale: &LanguageIdentifier) -> String;
    fn localize(&self) -> String;

[6.512]

[6.807]

    fn available_locales(&self) -> Vec<LanguageIdentifier>;
    fn message_for_locale(
        &self,
        writer: &mut W,
        locale: &LanguageIdentifier,
    ) -> Result<(), LocalizationError>;
    fn localize(&self, writer: &mut W) -> Result<(), LocalizationError> {
        let available_locales = self.available_locales();
        let selected_locale = locale_select::match_locales(
            &available_locales,
            &<Self as Localize<W>>::CANONICAL_LOCALE,
        );
        self.message_for_locale(writer, &selected_locale)
    }

Insertion in fluent_embed/Cargo.toml at line 11 [6.1078]
[17.4435]
[17.4435]
```
fluent_embed_derive = { path = "../fluent_embed_derive" }
```

Replacement in fluent_embed/Cargo.toml at line 18 [6.1078]

B:BD[6.1307] → [15.948:1006]

fluent_embed_derive = { path = "../fluent_embed_derive" }

[6.1307]

thiserror = "1.0.61"
writeable = "0.5.5"

Insertion in Cargo.lock at line 185 [19.4277]
[15.1212]
[15.1212]
```
 "thiserror",
 "writeable",
```