Resolve more pattern types into &str references

Author: JasperDeSutter

fluent-bundle/src/resolver/expression.rs

@@ -64,3 +64,45 @@ impl<'bundle> WriteValue<'bundle> for ast::Expression<&'bundle str> {
         }
     }
 }
+
+impl<'bundle> ResolveValue<'bundle> for ast::Expression<&'bundle str> {
+    fn resolve<'ast, 'args, 'errors, R, M>(
+        &'ast self,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+    ) -> FluentValue<'bundle>
+    where
+        R: Borrow<FluentResource>,
+        M: MemoizerKind,
+    {
+        match self {
+            Self::Inline(exp) => exp.resolve(scope),
+            Self::Select { selector, variants } => {
+                let selector = selector.resolve(scope);
+                match selector {
+                    FluentValue::String(_) | FluentValue::Number(_) => {
+                        for variant in variants {
+                            let key = match variant.key {
+                                ast::VariantKey::Identifier { name } => name.into(),
+                                ast::VariantKey::NumberLiteral { value } => {
+                                    FluentValue::try_number(value)
+                                }
+                            };
+                            if key.matches(&selector, scope) {
+                                return variant.value.resolve(scope);
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+
+                for variant in variants {
+                    if variant.default {
+                        return variant.value.resolve(scope);
+                    }
+                }
+                scope.add_error(ResolverError::MissingDefault);
+                FluentValue::Error
+            }
+        }
+    }
+}

fluent-bundle/src/resolver/inline_expression.rs

@@ -183,14 +183,72 @@ impl<'bundle> ResolveValue<'bundle> for ast::InlineExpression<&'bundle str> {
                     let result = func(resolved_positional_args.as_slice(), &resolved_named_args);
                     result
                 } else {
+                    scope.add_error(self.into());
+                    FluentValue::Error
+                }
+            }
+            ast::InlineExpression::MessageReference { id, attribute } => {
+                if let Some(msg) = scope.bundle.get_entry_message(id.name) {
+                    if let Some(attr) = attribute {
+                        msg.attributes
+                            .iter()
+                            .find_map(|a| {
+                                if a.id.name == attr.name {
+                                    Some(scope.track_resolve(&a.value))
+                                } else {
+                                    None
+                                }
+                            })
+                            .unwrap_or_else(|| {
+                                scope.add_error(self.into());
+                                FluentValue::Error
+                            })
+                    } else {
+                        msg.value
+                            .as_ref()
+                            .map(|value| scope.track_resolve(value))
+                            .unwrap_or_else(|| {
+                                scope.add_error(ResolverError::NoValue(id.name.to_string()));
+                                FluentValue::Error
+                            })
+                    }
+                } else {
+                    scope.add_error(self.into());
                     FluentValue::Error
                 }
             }
-            _ => {
-                let mut result = String::new();
-                self.write(&mut result, scope).expect("Failed to write");
-                result.into()
+            ast::InlineExpression::TermReference {
+                id,
+                attribute,
+                arguments,
+            } => {
+                let (_, resolved_named_args) = scope.get_arguments(arguments.as_ref());
+
+                scope.local_args = Some(resolved_named_args);
+                let result = scope
+                    .bundle
+                    .get_entry_term(id.name)
+                    .and_then(|term| {
+                        if let Some(attr) = attribute {
+                            term.attributes.iter().find_map(|a| {
+                                if a.id.name == attr.name {
+                                    Some(scope.track_resolve(&a.value))
+                                } else {
+                                    None
+                                }
+                            })
+                        } else {
+                            Some(scope.track_resolve(&term.value))
+                        }
+                    })
+                    .unwrap_or_else(|| {
+                        scope.add_error(self.into());
+                        FluentValue::Error
+                    });
+                scope.local_args = None;
+                result
             }
+            ast::InlineExpression::Placeable { expression } => expression.resolve(scope),
         }
     }
 }

fluent-bundle/src/resolver/pattern.rs

@@ -91,13 +91,33 @@ impl<'bundle> ResolveValue<'bundle> for ast::Pattern<&'bundle str> {
     {
         let len = self.elements.len();
 
+        // more than 1 element means concatenation, which is more efficient to write to a String
+        // 1 element often means just a message reference that can be passed back as a Cow::Borrowed
         if len == 1 {
-            if let ast::PatternElement::TextElement { value } = self.elements[0] {
-                return scope
-                    .bundle
-                    .transform
-                    .map_or_else(|| value.into(), |transform| transform(value).into());
-            }
+            match &self.elements[0] {
+                &ast::PatternElement::TextElement { value } => {
+                    return scope
+                        .bundle
+                        .transform
+                        .map_or_else(|| value.into(), |transform| transform(value).into());
+                }
+                ast::PatternElement::Placeable { expression } => {
+                    let before = scope.placeables;
+                    scope.placeables += 1;
+
+                    let res = scope.maybe_track_resolve(self, expression);
+                    if !matches!(res, FluentValue::Error) {
+                        return res;
+                    }
+
+                    // when hitting an error, reset scope state and format using writer below to write error information
+                    scope.placeables = before;
+                    scope.dirty = false;
+                    if let Some(err) = &mut scope.errors {
+                        err.pop();
+                    }
+                }
+            };
         }
 
         let mut result = String::new();

fluent-bundle/src/resolver/scope.rs

@@ -102,6 +102,49 @@ impl<'bundle, 'ast, 'args, 'errors, R, M> Scope<'bundle, 'ast, 'args, 'errors, R
         }
     }
 
+    /// Similar to [`Scope::maybe_track`], but resolves to a value
+    /// instead of writing to a Writer instance.
+    pub fn maybe_track_resolve(
+        &mut self,
+        pattern: &'ast ast::Pattern<&'bundle str>,
+        exp: &'ast ast::Expression<&'bundle str>,
+    ) -> FluentValue<'bundle>
+    where
+        R: Borrow<FluentResource>,
+        M: MemoizerKind,
+    {
+        if self.travelled.is_empty() {
+            self.travelled.push(pattern);
+        }
+        let res = exp.resolve(self);
+        if self.dirty {
+            FluentValue::Error
+        } else {
+            res
+        }
+    }
+
+    /// Similar to [`Scope::track`], but resolves to a value
+    /// instead of writing to a Writer instance.
+    pub fn track_resolve(
+        &mut self,
+        pattern: &'ast ast::Pattern<&'bundle str>,
+    ) -> FluentValue<'bundle>
+    where
+        R: Borrow<FluentResource>,
+        M: MemoizerKind,
+    {
+        if self.travelled.contains(&pattern) {
+            self.add_error(ResolverError::Cyclic);
+            FluentValue::Error
+        } else {
+            self.travelled.push(pattern);
+            let result = pattern.resolve(self);
+            self.travelled.pop();
+            result
+        }
+    }
+
     pub fn write_ref_error<W>(
         &mut self,
         w: &mut W,