Finchie/l10n_embed - Change 5TEX4MNUC4LDDRMNEOVCFNUUEZAGUXMKO3OIEQFXWRQKXSHY2NRQC

Split `fluent_embed` into `group` and `parse` modules

The lib.rs file was a bit of a mess, so this should make the boundary cleaner in preparation for creating an actual proc macro

Created by finchie on February 14, 2024

5TEX4MNUC4LDDRMNEOVCFNUUEZAGUXMKO3OIEQFXWRQKXSHY2NRQC

Dependencies

In channels

main

Change contents

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

[3.41]

use fluent_syntax::ast::{
    Expression, InlineExpression, Pattern, PatternElement, Variant, VariantKey,
};
use heck::{ToPascalCase, ToSnakeCase};
use quote::{format_ident, quote};
use syn::parse_quote;
pub(crate) fn match_fluent_pattern<'resource>(
    pattern: &'resource Pattern<&'resource str>,
) -> syn::Expr {
    let mut format_body = String::new();
    let mut format_arguments = Vec::new();
    for element in &pattern.elements {
        match element {
            PatternElement::TextElement { value } => format_body.push_str(value),
            PatternElement::Placeable { expression } => {
                let expression = match_placeable_expression(&expression);
                format_body.push_str("{}");
                format_arguments.push(quote!(#expression));
            }
        }
    }
    let format_body_literal = proc_macro2::Literal::string(format_body.to_string().as_str());
    parse_quote!(format!(#format_body_literal, #(#format_arguments),*))
}
fn match_placeable_expression<'resource>(
    expression: &'resource Expression<&'resource str>,
) -> syn::Expr {
    match expression {
        Expression::Select { selector, variants } => {
            let match_target = match_inline_expression(selector);
            let match_arms: Vec<syn::Arm> = variants.iter().map(match_variant).collect();
            parse_quote! {
                match plural_rules.category_for(*#match_target) {
                    #(#match_arms),*
                }
            }
        }
        Expression::Inline(expression) => match_inline_expression(expression),
    }
}
fn match_inline_expression<'resource>(
    expression: &'resource InlineExpression<&'resource str>,
) -> syn::Expr {
    match expression {
        InlineExpression::StringLiteral { value } => {
            let string_literal = proc_macro2::Literal::string(value);
            parse_quote!(#string_literal)
        }
        InlineExpression::NumberLiteral { value } => {
            // FIXME: i128 is "good enough" for now but an incorrect representation!
            // e.g. decimals not supported
            let parsed_value = i128::from_str_radix(value, 10).unwrap();
            let number_literal = proc_macro2::Literal::i128_unsuffixed(parsed_value);
            parse_quote!(#number_literal)
        }
        InlineExpression::VariableReference { id } => {
            let ident = format_ident!("{}", id.name.to_snake_case());
            parse_quote!(#ident)
        }
        _ => {
            dbg!(expression);
            todo!()
        }
    }
}
fn match_variant<'resource>(variant: &Variant<&'resource str>) -> syn::Arm {
    let base_pattern = match_pattern(&variant.key);
    let body = match_fluent_pattern(&variant.value);
    // 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 | _)
    } else {
        base_pattern
    };
    parse_quote!(#pattern => #body)
}
fn match_pattern<'resource>(pattern: &VariantKey<&'resource str>) -> syn::Pat {
    match pattern {
        VariantKey::Identifier { name } => {
            let ident = format_ident!("{}", name.to_pascal_case());
            parse_quote!(::icu_plurals::PluralCategory::#ident)
        }
        VariantKey::NumberLiteral { value } => todo!(),
    }
}

Replacement in fluent_embed/src/lib.rs at line 1 [3.74]

B:BD[3.74] → [4.0:26]

B:BD[4.26] → [5.0:110]

∅:D[5.110] → [4.111:114]

B:BD[4.111] → [4.111:114]

B:BD[4.114] → [2.0:52]

∅:D[6.43] → [5.139:173]

∅:D[2.52] → [5.139:173]

B:BD[5.139] → [5.139:173]

∅:D[4.132] → [7.68:90]

∅:D[5.173] → [7.68:90]

B:BD[7.68] → [7.68:90]

∅:D[7.90] → [3.127:145]

B:BD[3.127] → [3.127:145]

B:BD[3.145] → [7.91:124]

∅:D[7.124] → [3.174:315]

B:BD[3.174] → [3.174:315]

B:BD[3.315] → [7.125:225]

B:BD[7.225] → [4.133:228]

B:BD[4.228] → [5.174:247]

∅:D[5.247] → [7.554:570]

∅:D[4.294] → [7.554:570]

B:BD[7.554] → [7.554:570]

B:BD[7.570] → [6.44:174]

∅:D[6.174] → [3.315:991]

∅:D[7.570] → [3.315:991]

B:BD[3.315] → [3.315:991]

B:BD[3.991] → [7.571:577]

B:BD[7.577] → [6.175:456]

∅:D[6.456] → [7.577:578]

B:BD[7.577] → [7.577:578]

B:BD[7.578] → [6.457:749]

B:BD[6.749] → [8.0:323]

B:BD[8.323] → [2.53:215]

∅:D[2.215] → [6.749:750]

∅:D[8.428] → [6.749:750]

B:BD[6.749] → [6.749:750]

B:BD[6.750] → [8.429:643]

∅:D[8.643] → [6.790:889]

B:BD[6.790] → [6.790:889]

B:BD[6.889] → [9.0:90]

∅:D[9.90] → [6.936:1089]

B:BD[6.936] → [6.936:1089]

∅:D[7.796] → [3.991:999]

∅:D[6.1089] → [3.991:999]

B:BD[3.991] → [3.991:999]

B:BD[3.999] → [4.295:296]

B:BD[4.296] → [5.248:343]

∅:D[5.343] → [10.62:146]

B:BD[4.384] → [10.62:146]

∅:D[10.146] → [4.507:571]

B:BD[4.507] → [4.507:571]

B:BD[4.571] → [10.147:229]

∅:D[10.229] → [4.660:792]

B:BD[4.660] → [4.660:792]

B:BD[4.792] → [10.230:334]

∅:D[10.334] → [4.902:932]

B:BD[4.902] → [4.902:932]

∅:D[4.932] → [7.797:798]

B:BD[3.999] → [7.797:798]

B:BD[7.798] → [4.933:1028]

B:BD[4.1028] → [10.335:407]

∅:D[10.407] → [4.1095:1235]

B:BD[4.1095] → [4.1095:1235]

B:BD[4.1235] → [5.344:583]

B:BD[5.583] → [9.91:212]

∅:D[9.212] → [5.974:975]

B:BD[5.974] → [5.974:975]

B:BD[5.1125] → [5.1125:1149]

∅:D[5.1149] → [4.1323:1511]

B:BD[4.1323] → [4.1323:1511]

∅:D[4.1511] → [7.899:916]

B:BD[7.899] → [7.899:916]

B:BD[7.916] → [4.1512:2106]

B:BD[4.2106] → [5.1150:1206]

B:BD[5.1206] → [2.216:286]

∅:D[2.286] → [5.1260:1386]

B:BD[5.1260] → [5.1260:1386]

use fluent_syntax::ast::{
    Entry, Expression, InlineExpression, Message, Pattern, PatternElement, Resource, Variant,
    VariantKey,
};
use heck::{ToKebabCase, ToPascalCase, ToSnakeCase};
use quote::{format_ident, quote};
use syn::parse_quote;
#[derive(Debug)]
pub enum GroupEntry<'resource> {
    Message(&'resource Message<&'resource str>),
}
#[derive(Debug)]
pub struct Group<'resource> {
    children: Vec<GroupEntry<'resource>>,
}
impl<'resource> GroupEntry<'resource> {
    fn to_syn(&self) -> syn::Expr {
        match self {
            Self::Message(message) => message
                .value
                .as_ref()
                .map_or_else(|| parse_quote!(()), match_fluent_pattern),
        }
    }
    fn id(&self) -> &'resource str {
        match self {
            Self::Message(message) => message.id.name,
        }
    }
}
impl<'resource> TryFrom<&'resource Entry<&'resource str>> for GroupEntry<'resource> {
    type Error = ();
    fn try_from(value: &'resource Entry<&'resource str>) -> Result<Self, Self::Error> {
        match value {
            Entry::Message(message) => Ok(Self::Message(message)),
            _ => Err(()),
        }
    }
}
impl<'resource> Group<'resource> {
    pub fn from_resource(resource: &'resource Resource<&'resource str>) -> Self {
        let mut children = Vec::new();
        for entry in &resource.body {
            let matched_entry = GroupEntry::try_from(entry).unwrap();
            children.push(matched_entry);
        }
        Self { children }
    }
    pub fn derive_enum(
        &self,
        ident: syn::Ident,
        enum_data: syn::DataEnum,
    ) -> proc_macro2::TokenStream {
        let mut idents = Vec::with_capacity(enum_data.variants.len());
        let mut messages = Vec::with_capacity(enum_data.variants.len());
        for variant in enum_data.variants {
            let kebab_case_ident = variant.ident.to_string().to_kebab_case();
            let message = self
                .children
                .iter()
                .find(|child| child.id() == kebab_case_ident)
                .unwrap();
            let variant_ident = variant.ident;
            idents.push(match variant.fields {
                syn::Fields::Named(fields) => {
                    // Get the name of each field for pattern-matching
                    let field_idents = fields
                        .named
                        .iter()
                        .map(|field| field.ident.as_ref().unwrap())
                        .map(|ident| format_ident!("{}", ident.to_string().to_snake_case()));
                    quote!(#variant_ident { #(#field_idents),* })
                }
                syn::Fields::Unnamed(_) => todo!(),
                syn::Fields::Unit => quote!(#variant_ident),
            });
            messages.push(message.to_syn());
        }
        quote! {
            impl #ident {
                fn localize(&self, plural_rules: &::icu_plurals::PluralRules) -> String {
                    match self {
                        #(Self::#idents => #messages),*
                    }
                }
            }
        }
    }
}
fn match_fluent_pattern<'resource>(pattern: &'resource Pattern<&'resource str>) -> syn::Expr {
    let mut format_body = String::new();
    let mut format_arguments = Vec::new();
    for element in &pattern.elements {
        match element {
            PatternElement::TextElement { value } => format_body.push_str(value),
            PatternElement::Placeable { expression } => {
                let expression = match_placeable_expression(&expression);
                format_body.push_str("{}");
                format_arguments.push(quote!(#expression));
            }
        }
    }
    let format_body_literal = proc_macro2::Literal::string(format_body.to_string().as_str());
    parse_quote!(format!(#format_body_literal, #(#format_arguments),*))
}
fn match_placeable_expression<'resource>(
    expression: &'resource Expression<&'resource str>,
) -> syn::Expr {
    match expression {
        Expression::Select { selector, variants } => {
            let match_target = match_inline_expression(selector);
            let match_arms: Vec<syn::Arm> = variants.iter().map(match_variant).collect();
            parse_quote! {
                match plural_rules.category_for(*#match_target) {
                    #(#match_arms),*
                }
            }
        }
        Expression::Inline(expression) => match_inline_expression(expression),
    }
}
fn match_inline_expression<'resource>(
    expression: &'resource InlineExpression<&'resource str>,
) -> syn::Expr {
    match expression {
        InlineExpression::StringLiteral { value } => {
            let string_literal = proc_macro2::Literal::string(value);
            parse_quote!(#string_literal)
        }
        InlineExpression::NumberLiteral { value } => {
            // FIXME: i128 is "good enough" for now but an incorrect representation!
            // e.g. decimals not supported
            let parsed_value = i128::from_str_radix(value, 10).unwrap();
            let number_literal = proc_macro2::Literal::i128_unsuffixed(parsed_value);
            parse_quote!(#number_literal)
        }
        InlineExpression::VariableReference { id } => {
            let ident = format_ident!("{}", id.name.to_snake_case());
            parse_quote!(#ident)
        }
        _ => {
            dbg!(expression);
            todo!()
        }
    }
}

[3.74]

[5.1386]

mod group;
mod parse;

Replacement in fluent_embed/src/lib.rs at line 4 [3.74]

B:BD[5.1387] → [5.1387:2051]

B:BD[5.2051] → [2.287:355]

∅:D[2.355] → [9.213:277]

B:BD[5.2124] → [9.213:277]

∅:D[9.277] → [5.2173:2239]

B:BD[5.2173] → [5.2173:2239]

∅:D[5.2239] → [7.1040:1048]

B:BD[7.1040] → [7.1040:1048]

fn match_variant<'resource>(variant: &Variant<&'resource str>) -> syn::Arm {
    let base_pattern = match_pattern(&variant.key);
    let body = match_fluent_pattern(&variant.value);
    // 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 | _)
    } else {
        base_pattern
    };
    parse_quote!(#pattern => #body)
}
fn match_pattern<'resource>(pattern: &VariantKey<&'resource str>) -> syn::Pat {
    match pattern {
        VariantKey::Identifier { name } => {
            let ident = format_ident!("{}", name.to_pascal_case());
            parse_quote!(::icu_plurals::PluralCategory::#ident)
        }
        VariantKey::NumberLiteral { value } => todo!(),
    }
}

[5.1387]

pub use group::Group;

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

[3.41]

use fluent_syntax::ast::{Entry, Message, Resource};
use heck::{ToKebabCase, ToSnakeCase};
use quote::{format_ident, quote};
use syn::parse_quote;
#[derive(Debug)]
pub enum GroupEntry<'resource> {
    Message(&'resource Message<&'resource str>),
}
#[derive(Debug)]
pub struct Group<'resource> {
    children: Vec<GroupEntry<'resource>>,
}
impl<'resource> GroupEntry<'resource> {
    fn to_syn(&self) -> syn::Expr {
        match self {
            Self::Message(message) => message
                .value
                .as_ref()
                .map_or_else(|| parse_quote!(()), crate::parse::match_fluent_pattern),
        }
    }
    fn id(&self) -> &'resource str {
        match self {
            Self::Message(message) => message.id.name,
        }
    }
}
impl<'resource> TryFrom<&'resource Entry<&'resource str>> for GroupEntry<'resource> {
    type Error = ();
    fn try_from(value: &'resource Entry<&'resource str>) -> Result<Self, Self::Error> {
        match value {
            Entry::Message(message) => Ok(Self::Message(message)),
            _ => Err(()),
        }
    }
}
impl<'resource> Group<'resource> {
    pub fn from_resource(resource: &'resource Resource<&'resource str>) -> Self {
        let mut children = Vec::new();
        for entry in &resource.body {
            let matched_entry = GroupEntry::try_from(entry).unwrap();
            children.push(matched_entry);
        }
        Self { children }
    }
    pub fn derive_enum(
        &self,
        ident: syn::Ident,
        enum_data: syn::DataEnum,
    ) -> proc_macro2::TokenStream {
        let mut idents = Vec::with_capacity(enum_data.variants.len());
        let mut messages = Vec::with_capacity(enum_data.variants.len());
        for variant in enum_data.variants {
            let kebab_case_ident = variant.ident.to_string().to_kebab_case();
            let message = self
                .children
                .iter()
                .find(|child| child.id() == kebab_case_ident)
                .unwrap();
            let variant_ident = variant.ident;
            idents.push(match variant.fields {
                syn::Fields::Named(fields) => {
                    // Get the name of each field for pattern-matching
                    let field_idents = fields
                        .named
                        .iter()
                        .map(|field| field.ident.as_ref().unwrap())
                        .map(|ident| format_ident!("{}", ident.to_string().to_snake_case()));
                    quote!(#variant_ident { #(#field_idents),* })
                }
                syn::Fields::Unnamed(_) => todo!(),
                syn::Fields::Unit => quote!(#variant_ident),
            });
            messages.push(message.to_syn());
        }
        quote! {
            impl #ident {
                fn localize(&self, plural_rules: &::icu_plurals::PluralRules) -> String {
                    match self {
                        #(Self::#idents => #messages),*
                    }
                }
            }
        }
    }
}