Increase test coverage and slightly speed up resolver by bringing more of the Writer goodies

Author: zbraniecki

fluent-bundle/src/errors.rs

@@ -11,12 +11,6 @@ pub enum FluentError {
     ResolverError(ResolverError),
 }
 
-impl From<ParserError> for FluentError {
-    fn from(error: ParserError) -> Self {
-        FluentError::ParserError(error)
-    }
-}
-
 impl From<ResolverError> for FluentError {
     fn from(error: ResolverError) -> Self {
         FluentError::ResolverError(error)

fluent-bundle/src/resolve.rs

@@ -157,9 +157,6 @@ impl<'source> ResolveValue<'source> for ast::Pattern<'source> {
                     string.push_str(&s);
                 }
                 ast::PatternElement::Placeable(p) => {
-                    let result = scope
-                        .maybe_track(self, None, |scope| p.resolve(scope))
-                        .to_string();
                     let needs_isolation = scope.bundle.use_isolating
                         && match p {
                             ast::Expression::InlineExpression(
@@ -174,10 +171,13 @@ impl<'source> ResolveValue<'source> for ast::Pattern<'source> {
                             _ => true,
                         };
                     if needs_isolation {
-                        write!(string, "\u{2068}{}\u{2069}", result).expect("Writing succeeded");
-                    } else {
-                        write!(string, "{}", result).expect("Writing succeeded");
-                    };
+                        string.write_char('\u{2068}').expect("Writing succeeded");
+                    }
+                    let result = scope.maybe_track(self, None, |scope| p.resolve(scope));
+                    write!(string, "{}", result).expect("Writing succeeded");
+                    if needs_isolation {
+                        string.write_char('\u{2069}').expect("Writing succeeded");
+                    }
                 }
             }
         }

fluent-bundle/src/types.rs

@@ -72,18 +72,6 @@ impl<'source> From<&ast::Message<'source>> for DisplayableNode<'source> {
     }
 }
 
-impl<'source> From<(&ast::Message<'source>, &ast::Attribute<'source>)>
-    for DisplayableNode<'source>
-{
-    fn from(input: (&ast::Message<'source>, &ast::Attribute<'source>)) -> Self {
-        DisplayableNode {
-            node_type: DisplayableNodeType::Message,
-            id: input.0.id.name,
-            attribute: Some(input.1.id.name),
-        }
-    }
-}
-
 impl<'source> From<&ast::Term<'source>> for DisplayableNode<'source> {
     fn from(term: &ast::Term<'source>) -> Self {
         DisplayableNode {
@@ -179,10 +167,10 @@ impl<'source> FluentValue<'source> {
 impl<'source> fmt::Display for FluentValue<'source> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            FluentValue::String(s) => write!(f, "{}", s),
-            FluentValue::Number(n) => write!(f, "{}", n),
+            FluentValue::String(s) => f.write_str(s),
+            FluentValue::Number(n) => f.write_str(n),
             FluentValue::Error(d) => write!(f, "{}", d),
-            FluentValue::None() => write!(f, "???"),
+            FluentValue::None() => f.write_str("???"),
         }
     }
 }

fluent-bundle/tests/bundle_test.rs

@@ -72,10 +72,11 @@ bar =
 #[test]
 fn bundle_use_isolating() {
     let res = assert_get_resource_from_str_no_errors(
-        "
+        r#"
+-brand-name = Fluent
 foo = Foo
-bar = Foo { $name } bar
-    ",
+bar = Foo { $name } bar { -brand-name } baz { "Literal" }
+    "#,
     );
     let mut bundle = assert_get_bundle_no_errors(&res, None);
 
@@ -87,13 +88,16 @@ bar = Foo { $name } bar
     args.insert("name", "John".into());
     assert_format_no_errors(
         bundle.format("bar", Some(&args)),
-        "Foo \u{2068}John\u{2069} bar",
+        "Foo \u{2068}John\u{2069} bar Fluent baz Literal",
     );
 
     bundle.set_use_isolating(false);
 
     assert_format_no_errors(bundle.format("foo", None), "Foo");
     let mut args = HashMap::new();
     args.insert("name", "John".into());
-    assert_format_no_errors(bundle.format("bar", Some(&args)), "Foo John bar");
+    assert_format_no_errors(
+        bundle.format("bar", Some(&args)),
+        "Foo John bar Fluent baz Literal",
+    );
 }

fluent-bundle/tests/primitives_test.rs

@@ -100,3 +100,15 @@ selector-attr = { -bazTerm.attr ->
 
     assert_format_no_errors(bundle.format("selector-attr", None), "FooBarBaz");
 }
+
+#[test]
+fn primitives_placeable() {
+    let res = assert_get_resource_from_str_no_errors(
+        r#"
+key = { { "Literal" } }
+    "#,
+    );
+    let bundle = assert_get_bundle_no_errors(&res, None);
+
+    assert_format_no_errors(bundle.format("key", None), "Literal");
+}