Auto merge of #18355 - servo:no-fmt, r=emilio

Reduce usage of fmt in serialization and error reporting

`format!` and `write!` create a somewhat-heavyweight `Formatting` struct and use dynamic dispatch to call into impls of `Dispaly` and related traits. The former also allocates an intermediate string that is sometimes unnecessary.

I started looking into this from https://bugzilla.mozilla.org/show_bug.cgi?id=1355599, but I expect the impact there will be small to insignificant. It might be a slightly less so on parsing (error reporting).

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/18355)
<!-- Reviewable:end -->

components/style/counter_style/mod.rs

@@ -327,7 +327,8 @@ impl ToCss for System {
             System::Additive => dest.write_str("additive"),
             System::Fixed { first_symbol_value } => {
                 if let Some(value) = first_symbol_value {
-                    write!(dest, "fixed {}", value)
+                    dest.write_str("fixed ")?;
+                    value.to_css(dest)
                 } else {
                     dest.write_str("fixed")
                 }
@@ -455,7 +456,7 @@ where W: fmt::Write {
 
 fn bound_to_css<W>(range: Option<i32>, dest: &mut W) -> fmt::Result where W: fmt::Write {
     if let Some(finite) = range {
-        write!(dest, "{}", finite)
+        finite.to_css(dest)
     } else {
         dest.write_str("infinite")
     }

components/style/error_reporting.rs

@@ -9,6 +9,7 @@
 use cssparser::{BasicParseError, Token, SourceLocation};
 use cssparser::ParseError as CssParseError;
 use log;
+use std::fmt;
 use style_traits::ParseError;
 use stylesheets::UrlExtraData;
 
@@ -46,104 +47,127 @@ pub enum ContextualParseError<'a> {
     InvalidCounterStyleExtendsWithAdditiveSymbols
 }
 
-impl<'a> ContextualParseError<'a> {
-    /// Turn a parse error into a string representation.
-    pub fn to_string(&self) -> String {
-        fn token_to_str(t: &Token) -> String {
+impl<'a> fmt::Display for ContextualParseError<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fn token_to_str(t: &Token, f: &mut fmt::Formatter) -> fmt::Result {
             match *t {
-                Token::Ident(ref i) => format!("identifier {}", i),
-                Token::AtKeyword(ref kw) => format!("keyword @{}", kw),
-                Token::Hash(ref h) => format!("hash #{}", h),
-                Token::IDHash(ref h) => format!("id selector #{}", h),
-                Token::QuotedString(ref s) => format!("quoted string \"{}\"", s),
-                Token::UnquotedUrl(ref u) => format!("url {}", u),
-                Token::Delim(ref d) => format!("delimiter {}", d),
-                Token::Number { int_value: Some(i), .. } => format!("number {}", i),
-                Token::Number { value, .. } => format!("number {}", value),
-                Token::Percentage { int_value: Some(i), .. } => format!("percentage {}", i),
-                Token::Percentage { unit_value, .. } => format!("percentage {}", unit_value * 100.),
-                Token::Dimension { value, ref unit, .. } => format!("dimension {}{}", value, unit),
-                Token::WhiteSpace(_) => format!("whitespace"),
-                Token::Comment(_) => format!("comment"),
-                Token::Colon => format!("colon (:)"),
-                Token::Semicolon => format!("semicolon (;)"),
-                Token::Comma => format!("comma (,)"),
-                Token::IncludeMatch => format!("include match (~=)"),
-                Token::DashMatch => format!("dash match (|=)"),
-                Token::PrefixMatch => format!("prefix match (^=)"),
-                Token::SuffixMatch => format!("suffix match ($=)"),
-                Token::SubstringMatch => format!("substring match (*=)"),
-                Token::Column => format!("column (||)"),
-                Token::CDO => format!("CDO (<!--)"),
-                Token::CDC => format!("CDC (-->)"),
-                Token::Function(ref f) => format!("function {}", f),
-                Token::ParenthesisBlock => format!("parenthesis ("),
-                Token::SquareBracketBlock => format!("square bracket ["),
-                Token::CurlyBracketBlock => format!("curly bracket {{"),
-                Token::BadUrl(ref _u) => format!("bad url parse error"),
-                Token::BadString(ref _s) => format!("bad string parse error"),
-                Token::CloseParenthesis => format!("unmatched close parenthesis"),
-                Token::CloseSquareBracket => format!("unmatched close square bracket"),
-                Token::CloseCurlyBracket => format!("unmatched close curly bracket"),
+                Token::Ident(ref i) => write!(f, "identifier {}", i),
+                Token::AtKeyword(ref kw) => write!(f, "keyword @{}", kw),
+                Token::Hash(ref h) => write!(f, "hash #{}", h),
+                Token::IDHash(ref h) => write!(f, "id selector #{}", h),
+                Token::QuotedString(ref s) => write!(f, "quoted string \"{}\"", s),
+                Token::UnquotedUrl(ref u) => write!(f, "url {}", u),
+                Token::Delim(ref d) => write!(f, "delimiter {}", d),
+                Token::Number { int_value: Some(i), .. } => write!(f, "number {}", i),
+                Token::Number { value, .. } => write!(f, "number {}", value),
+                Token::Percentage { int_value: Some(i), .. } => write!(f, "percentage {}", i),
+                Token::Percentage { unit_value, .. } => write!(f, "percentage {}", unit_value * 100.),
+                Token::Dimension { value, ref unit, .. } => write!(f, "dimension {}{}", value, unit),
+                Token::WhiteSpace(_) => write!(f, "whitespace"),
+                Token::Comment(_) => write!(f, "comment"),
+                Token::Colon => write!(f, "colon (:)"),
+                Token::Semicolon => write!(f, "semicolon (;)"),
+                Token::Comma => write!(f, "comma (,)"),
+                Token::IncludeMatch => write!(f, "include match (~=)"),
+                Token::DashMatch => write!(f, "dash match (|=)"),
+                Token::PrefixMatch => write!(f, "prefix match (^=)"),
+                Token::SuffixMatch => write!(f, "suffix match ($=)"),
+                Token::SubstringMatch => write!(f, "substring match (*=)"),
+                Token::Column => write!(f, "column (||)"),
+                Token::CDO => write!(f, "CDO (<!--)"),
+                Token::CDC => write!(f, "CDC (-->)"),
+                Token::Function(ref name) => write!(f, "function {}", name),
+                Token::ParenthesisBlock => write!(f, "parenthesis ("),
+                Token::SquareBracketBlock => write!(f, "square bracket ["),
+                Token::CurlyBracketBlock => write!(f, "curly bracket {{"),
+                Token::BadUrl(ref _u) => write!(f, "bad url parse error"),
+                Token::BadString(ref _s) => write!(f, "bad string parse error"),
+                Token::CloseParenthesis => write!(f, "unmatched close parenthesis"),
+                Token::CloseSquareBracket => write!(f, "unmatched close square bracket"),
+                Token::CloseCurlyBracket => write!(f, "unmatched close curly bracket"),
             }
         }
 
-        fn parse_error_to_str(err: &ParseError) -> String {
+        fn parse_error_to_str(err: &ParseError, f: &mut fmt::Formatter) -> fmt::Result {
             match *err {
-                CssParseError::Basic(BasicParseError::UnexpectedToken(ref t)) =>
-                    format!("found unexpected {}", token_to_str(t)),
-                CssParseError::Basic(BasicParseError::EndOfInput) =>
-                    format!("unexpected end of input"),
-                CssParseError::Basic(BasicParseError::AtRuleInvalid(ref i)) =>
-                    format!("@ rule invalid: {}", i),
-                CssParseError::Basic(BasicParseError::AtRuleBodyInvalid) =>
-                    format!("@ rule invalid"),
-                CssParseError::Basic(BasicParseError::QualifiedRuleInvalid) =>
-                    format!("qualified rule invalid"),
-                CssParseError::Custom(ref err) =>
-                    format!("{:?}", err)
+                CssParseError::Basic(BasicParseError::UnexpectedToken(ref t)) => {
+                    write!(f, "found unexpected ")?;
+                    token_to_str(t, f)
+                }
+                CssParseError::Basic(BasicParseError::EndOfInput) => {
+                    write!(f, "unexpected end of input")
+                }
+                CssParseError::Basic(BasicParseError::AtRuleInvalid(ref i)) => {
+                    write!(f, "@ rule invalid: {}", i)
+                }
+                CssParseError::Basic(BasicParseError::AtRuleBodyInvalid) => {
+                    write!(f, "@ rule invalid")
+                }
+                CssParseError::Basic(BasicParseError::QualifiedRuleInvalid) => {
+                    write!(f, "qualified rule invalid")
+                }
+                CssParseError::Custom(ref err) => {
+                    write!(f, "{:?}", err)
+                }
             }
         }
 
         match *self {
-            ContextualParseError::UnsupportedPropertyDeclaration(decl, ref err) =>
-                format!("Unsupported property declaration: '{}', {}", decl,
-                        parse_error_to_str(err)),
-            ContextualParseError::UnsupportedFontFaceDescriptor(decl, ref err) =>
-                format!("Unsupported @font-face descriptor declaration: '{}', {}", decl,
-                        parse_error_to_str(err)),
-            ContextualParseError::UnsupportedFontFeatureValuesDescriptor(decl, ref err) =>
-            format!("Unsupported @font-feature-values descriptor declaration: '{}', {}", decl,
-                    parse_error_to_str(err)),
-            ContextualParseError::InvalidKeyframeRule(rule, ref err) =>
-                format!("Invalid keyframe rule: '{}', {}", rule,
-                        parse_error_to_str(err)),
-            ContextualParseError::InvalidFontFeatureValuesRule(rule, ref err) =>
-            format!("Invalid font feature value rule: '{}', {}", rule,
-                    parse_error_to_str(err)),
-            ContextualParseError::UnsupportedKeyframePropertyDeclaration(decl, ref err) =>
-                format!("Unsupported keyframe property declaration: '{}', {}", decl,
-                        parse_error_to_str(err)),
-            ContextualParseError::InvalidRule(rule, ref err) =>
-                format!("Invalid rule: '{}', {}", rule, parse_error_to_str(err)),
-            ContextualParseError::UnsupportedRule(rule, ref err) =>
-                format!("Unsupported rule: '{}', {}", rule, parse_error_to_str(err)),
-            ContextualParseError::UnsupportedViewportDescriptorDeclaration(decl, ref err) =>
-                format!("Unsupported @viewport descriptor declaration: '{}', {}", decl,
-                        parse_error_to_str(err)),
-            ContextualParseError::UnsupportedCounterStyleDescriptorDeclaration(decl, ref err) =>
-                format!("Unsupported @counter-style descriptor declaration: '{}', {}", decl,
-                        parse_error_to_str(err)),
-            ContextualParseError::InvalidCounterStyleWithoutSymbols(ref system) =>
-                format!("Invalid @counter-style rule: 'system: {}' without 'symbols'", system),
-            ContextualParseError::InvalidCounterStyleNotEnoughSymbols(ref system) =>
-                format!("Invalid @counter-style rule: 'system: {}' less than two 'symbols'", system),
-            ContextualParseError::InvalidCounterStyleWithoutAdditiveSymbols =>
-                "Invalid @counter-style rule: 'system: additive' without 'additive-symbols'".into(),
-            ContextualParseError::InvalidCounterStyleExtendsWithSymbols =>
-                "Invalid @counter-style rule: 'system: extends …' with 'symbols'".into(),
-            ContextualParseError::InvalidCounterStyleExtendsWithAdditiveSymbols =>
-                "Invalid @counter-style rule: 'system: extends …' with 'additive-symbols'".into(),
+            ContextualParseError::UnsupportedPropertyDeclaration(decl, ref err) => {
+                write!(f, "Unsupported property declaration: '{}', ", decl)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::UnsupportedFontFaceDescriptor(decl, ref err) => {
+                write!(f, "Unsupported @font-face descriptor declaration: '{}', ", decl)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::UnsupportedFontFeatureValuesDescriptor(decl, ref err) => {
+                write!(f, "Unsupported @font-feature-values descriptor declaration: '{}', ", decl)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::InvalidKeyframeRule(rule, ref err) => {
+                write!(f, "Invalid keyframe rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::InvalidFontFeatureValuesRule(rule, ref err) => {
+                write!(f, "Invalid font feature value rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::UnsupportedKeyframePropertyDeclaration(decl, ref err) => {
+                write!(f, "Unsupported keyframe property declaration: '{}', ", decl)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::InvalidRule(rule, ref err) => {
+                write!(f, "Invalid rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::UnsupportedRule(rule, ref err) => {
+                write!(f, "Unsupported rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::UnsupportedViewportDescriptorDeclaration(decl, ref err) => {
+                write!(f, "Unsupported @viewport descriptor declaration: '{}', ", decl)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::UnsupportedCounterStyleDescriptorDeclaration(decl, ref err) => {
+                write!(f, "Unsupported @counter-style descriptor declaration: '{}', ", decl)?;
+                parse_error_to_str(err, f)
+            }
+            ContextualParseError::InvalidCounterStyleWithoutSymbols(ref system) => {
+                write!(f, "Invalid @counter-style rule: 'system: {}' without 'symbols'", system)
+            }
+            ContextualParseError::InvalidCounterStyleNotEnoughSymbols(ref system) => {
+                write!(f, "Invalid @counter-style rule: 'system: {}' less than two 'symbols'", system)
+            }
+            ContextualParseError::InvalidCounterStyleWithoutAdditiveSymbols => {
+                write!(f, "Invalid @counter-style rule: 'system: additive' without 'additive-symbols'")
+            }
+            ContextualParseError::InvalidCounterStyleExtendsWithSymbols => {
+                write!(f, "Invalid @counter-style rule: 'system: extends …' with 'symbols'")
+            }
+            ContextualParseError::InvalidCounterStyleExtendsWithAdditiveSymbols => {
+                write!(f, "Invalid @counter-style rule: 'system: extends …' with 'additive-symbols'")
+            }
         }
     }
 }
@@ -174,7 +198,7 @@ impl ParseErrorReporter for RustLogReporter {
                     location: SourceLocation,
                     error: ContextualParseError) {
         if log_enabled!(log::LogLevel::Info) {
-            info!("Url:\t{}\n{}:{} {}", url.as_str(), location.line, location.column, error.to_string())
+            info!("Url:\t{}\n{}:{} {}", url.as_str(), location.line, location.column, error)
         }
     }
 }

components/style/gecko/media_queries.rs

@@ -399,7 +399,9 @@ impl MediaExpressionValue {
                 dest.write_str(if v { "1" } else { "0" })
             },
             MediaExpressionValue::IntRatio(a, b) => {
-                write!(dest, "{}/{}", a, b)
+                a.to_css(dest)?;
+                dest.write_char('/')?;
+                b.to_css(dest)
             },
             MediaExpressionValue::Resolution(ref r) => r.to_css(dest),
             MediaExpressionValue::Ident(ref ident) => {

components/style/gecko/selector_parser.rs

@@ -70,7 +70,7 @@ impl ToCss for NonTSPseudoClass {
                 match *self {
                     $(NonTSPseudoClass::$name => concat!(":", $css),)*
                     $(NonTSPseudoClass::$s_name(ref s) => {
-                        write!(dest, ":{}(", $s_css)?;
+                        dest.write_str(concat!(":", $s_css, "("))?;
                         {
                             // FIXME(emilio): Avoid the extra allocation!
                             let mut css = CssStringWriter::new(dest);
@@ -84,7 +84,9 @@ impl ToCss for NonTSPseudoClass {
                     $(NonTSPseudoClass::$k_name(ref s) => {
                         // Don't include the terminating nul.
                         let value = String::from_utf16(&s[..s.len() - 1]).unwrap();
-                        return write!(dest, ":{}({})", $k_css, value)
+                        dest.write_str(concat!(":", $k_css, "("))?;
+                        dest.write_str(&value)?;
+                        return dest.write_char(')')
                     }, )*
                     NonTSPseudoClass::MozAny(ref selectors) => {
                         dest.write_str(":-moz-any(")?;

components/style/macros.rs

@@ -88,7 +88,7 @@ macro_rules! define_keyword_type {
 
         impl fmt::Debug for $name {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                write!(f, $css)
+                f.write_str($css)
             }
         }
 

components/style/media_queries.rs

@@ -96,7 +96,7 @@ impl ToCss for MediaQuery {
     {
         if let Some(qual) = self.qualifier {
             qual.to_css(dest)?;
-            write!(dest, " ")?;
+            dest.write_char(' ')?;
         }
 
         match self.media_type {
@@ -107,7 +107,7 @@ impl ToCss for MediaQuery {
                 // Otherwise, we'd serialize media queries like "(min-width:
                 // 40px)" in "all (min-width: 40px)", which is unexpected.
                 if self.qualifier.is_some() || self.expressions.is_empty() {
-                    write!(dest, "all")?;
+                    dest.write_str("all")?;
                 }
             },
             MediaQueryType::Concrete(MediaType(ref desc)) => desc.to_css(dest)?,
@@ -118,13 +118,13 @@ impl ToCss for MediaQuery {
         }
 
         if self.media_type != MediaQueryType::All || self.qualifier.is_some() {
-            write!(dest, " and ")?;
+            dest.write_str(" and ")?;
         }
 
         self.expressions[0].to_css(dest)?;
 
         for expr in self.expressions.iter().skip(1) {
-            write!(dest, " and ")?;
+            dest.write_str(" and ")?;
             expr.to_css(dest)?;
         }
         Ok(())

components/style/properties/longhand/box.mako.rs

@@ -631,7 +631,6 @@ ${helpers.predefined_type(
     use values::specified::{Angle, Integer, Length, LengthOrPercentage};
     use values::specified::{LengthOrNumber, LengthOrPercentageOrNumber as LoPoNumber, Number};
     use style_traits::ToCss;
-    use style_traits::values::Css;
 
     use std::fmt;
 
@@ -819,58 +818,99 @@ ${helpers.predefined_type(
                     m11, m12, m13, m14,
                     m21, m22, m23, m24,
                     m31, m32, m33, m34,
-                    m41, m42, m43, m44 } => write!(
-                        dest, "matrix3d({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {})",
-                        Css(m11), Css(m12), Css(m13), Css(m14),
-                        Css(m21), Css(m22), Css(m23), Css(m24),
-                        Css(m31), Css(m32), Css(m33), Css(m34),
-                        Css(m41), Css(m42), Css(m43), Css(m44)),
+                    m41, m42, m43, m44,
+                } => {
+                    serialize_function!(dest, matrix3d(
+                        m11, m12, m13, m14,
+                        m21, m22, m23, m24,
+                        m31, m32, m33, m34,
+                        m41, m42, m43, m44,
+                    ))
+                }
                 SpecifiedOperation::PrefixedMatrix3D {
                     m11, m12, m13, m14,
                     m21, m22, m23, m24,
                     m31, m32, m33, m34,
-                    ref m41, ref m42, ref m43, m44 } => write!(
-                        dest, "matrix3d({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {})",
-                        Css(m11), Css(m12), Css(m13), Css(m14),
-                        Css(m21), Css(m22), Css(m23), Css(m24),
-                        Css(m31), Css(m32), Css(m33), Css(m34),
-                        Css(m41), Css(m42), Css(m43), Css(m44)),
-                SpecifiedOperation::Skew(ax, None) => write!(dest, "skew({})", Css(ax)),
-                SpecifiedOperation::Skew(ax, Some(ay)) => write!(dest, "skew({}, {})", Css(ax), Css(ay)),
-                SpecifiedOperation::SkewX(angle) => write!(dest, "skewX({})", Css(angle)),
-                SpecifiedOperation::SkewY(angle) => write!(dest, "skewY({})", Css(angle)),
-                SpecifiedOperation::Translate(ref tx, None) => write!(dest, "translate({})", Css(tx)),
+                    ref m41, ref m42, ref m43, m44,
+                } => {
+                    serialize_function!(dest, matrix3d(
+                        m11, m12, m13, m14,
+                        m21, m22, m23, m24,
+                        m31, m32, m33, m34,
+                        m41, m42, m43, m44,
+                    ))
+                }
+                SpecifiedOperation::Skew(ax, None) => {
+                    serialize_function!(dest, skew(ax))
+                }
+                SpecifiedOperation::Skew(ax, Some(ay)) => {
+                    serialize_function!(dest, skew(ax, ay))
+                }
+                SpecifiedOperation::SkewX(angle) => {
+                    serialize_function!(dest, skewX(angle))
+                }
+                SpecifiedOperation::SkewY(angle) => {
+                    serialize_function!(dest, skewY(angle))
+                }
+                SpecifiedOperation::Translate(ref tx, None) => {
+                    serialize_function!(dest, translate(tx))
+                }
                 SpecifiedOperation::Translate(ref tx, Some(ref ty)) => {
-                    write!(dest, "translate({}, {})", Css(tx), Css(ty))
-                },
-                SpecifiedOperation::TranslateX(ref tx) => write!(dest, "translateX({})", Css(tx)),
-                SpecifiedOperation::TranslateY(ref ty) => write!(dest, "translateY({})", Css(ty)),
-                SpecifiedOperation::TranslateZ(ref tz) => write!(dest, "translateZ({})", Css(tz)),
-                SpecifiedOperation::Translate3D(ref tx, ref ty, ref tz) => write!(
-                    dest, "translate3d({}, {}, {})", Css(tx), Css(ty), Css(tz)),
-                SpecifiedOperation::Scale(factor, None) => write!(dest, "scale({})", Css(factor)),
-                SpecifiedOperation::Scale(sx, Some(sy)) => write!(dest, "scale({}, {})", Css(sx), Css(sy)),
-                SpecifiedOperation::ScaleX(sx) => write!(dest, "scaleX({})", Css(sx)),
-                SpecifiedOperation::ScaleY(sy) => write!(dest, "scaleY({})", Css(sy)),
-                SpecifiedOperation::ScaleZ(sz) => write!(dest, "scaleZ({})", Css(sz)),
+                    serialize_function!(dest, translate(tx, ty))
+                }
+                SpecifiedOperation::TranslateX(ref tx) => {
+                    serialize_function!(dest, translateX(tx))
+                }
+                SpecifiedOperation::TranslateY(ref ty) => {
+                    serialize_function!(dest, translateY(ty))
+                }
+                SpecifiedOperation::TranslateZ(ref tz) => {
+                    serialize_function!(dest, translateZ(tz))
+                }
+                SpecifiedOperation::Translate3D(ref tx, ref ty, ref tz) => {
+                    serialize_function!(dest, translate3d(tx, ty, tz))
+                }
+                SpecifiedOperation::Scale(factor, None) => {
+                    serialize_function!(dest, scale(factor))
+                }
+                SpecifiedOperation::Scale(sx, Some(sy)) => {
+                    serialize_function!(dest, scale(sx, sy))
+                }
+                SpecifiedOperation::ScaleX(sx) => {
+                    serialize_function!(dest, scaleX(sx))
+                }
+                SpecifiedOperation::ScaleY(sy) => {
+                    serialize_function!(dest, scaleY(sy))
+                }
+                SpecifiedOperation::ScaleZ(sz) => {
+                    serialize_function!(dest, scaleZ(sz))
+                }
                 SpecifiedOperation::Scale3D(sx, sy, sz) => {
-                    write!(dest, "scale3d({}, {}, {})", Css(sx), Css(sy), Css(sz))
-                },
-                SpecifiedOperation::Rotate(theta) => write!(dest, "rotate({})", Css(theta)),
-                SpecifiedOperation::RotateX(theta) => write!(dest, "rotateX({})", Css(theta)),
-                SpecifiedOperation::RotateY(theta) => write!(dest, "rotateY({})", Css(theta)),
-                SpecifiedOperation::RotateZ(theta) => write!(dest, "rotateZ({})", Css(theta)),
-                SpecifiedOperation::Rotate3D(x, y, z, theta) => write!(
-                    dest, "rotate3d({}, {}, {}, {})",
-                    Css(x), Css(y), Css(z), Css(theta)),
-                SpecifiedOperation::Perspective(ref length) => write!(dest, "perspective({})", Css(length)),
+                    serialize_function!(dest, scale3d(sx, sy, sz))
+                }
+                SpecifiedOperation::Rotate(theta) => {
+                    serialize_function!(dest, rotate(theta))
+                }
+                SpecifiedOperation::RotateX(theta) => {
+                    serialize_function!(dest, rotateX(theta))
+                }
+                SpecifiedOperation::RotateY(theta) => {
+                    serialize_function!(dest, rotateY(theta))
+                }
+                SpecifiedOperation::RotateZ(theta) => {
+                    serialize_function!(dest, rotateZ(theta))
+                }
+                SpecifiedOperation::Rotate3D(x, y, z, theta) => {
+                    serialize_function!(dest, rotate3d(x, y, z, theta))
+                }
+                SpecifiedOperation::Perspective(ref length) => {
+                    serialize_function!(dest, perspective(length))
+                }
                 SpecifiedOperation::InterpolateMatrix { ref from_list, ref to_list, progress } => {
-                    write!(dest, "interpolatematrix({}, {}, {})",
-                           Css(from_list), Css(to_list), Css(progress))
-                },
+                    serialize_function!(dest, interpolatematrix(from_list, to_list, progress))
+                }
                 SpecifiedOperation::AccumulateMatrix { ref from_list, ref to_list, count } => {
-                    write!(dest, "accumulatematrix({}, {}, {})",
-                           Css(from_list), Css(to_list), Css(count))
+                    serialize_function!(dest, accumulatematrix(from_list, to_list, count))
                 }
             }
         }

components/style/properties/longhand/font.mako.rs

@@ -273,7 +273,7 @@ macro_rules! impl_gecko_keyword_conversions {
                         % if product == "gecko":
                             // We should treat -moz-fixed as monospace
                             if name == &atom!("-moz-fixed") {
-                                return write!(dest, "monospace");
+                                return dest.write_str("monospace");
                             }
                         % endif
 

components/style/properties/shorthand/box.mako.rs

@@ -176,7 +176,7 @@ macro_rules! try_parse_one {
 
             for i in 0..len {
                 if i != 0 {
-                    write!(dest, ", ")?;
+                    dest.write_str(", ")?;
                 }
                 self.transition_property.0[i].to_css(dest)?;
                 % for name in "duration timing_function delay".split():
@@ -289,7 +289,7 @@ macro_rules! try_parse_one {
 
             for i in 0..len {
                 if i != 0 {
-                    write!(dest, ", ")?;
+                    dest.write_str(", ")?;
                 }
 
                 % for name in props[1:]:

components/style/servo/media_queries.rs

@@ -215,15 +215,14 @@ impl ToCss for Expression {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result
         where W: fmt::Write,
     {
-        write!(dest, "(")?;
-        let (mm, l) = match self.0 {
-            ExpressionKind::Width(Range::Min(ref l)) => ("min-", l),
-            ExpressionKind::Width(Range::Max(ref l)) => ("max-", l),
-            ExpressionKind::Width(Range::Eq(ref l)) => ("", l),
+        let (s, l) = match self.0 {
+            ExpressionKind::Width(Range::Min(ref l)) => ("(min-width: ", l),
+            ExpressionKind::Width(Range::Max(ref l)) => ("(max-width: ", l),
+            ExpressionKind::Width(Range::Eq(ref l)) => ("(width: ", l),
         };
-        write!(dest, "{}width: ", mm)?;
+        dest.write_str(s)?;
         l.to_css(dest)?;
-        write!(dest, ")")
+        dest.write_char(')')
     }
 }
 

components/style/stylesheets/font_feature_values_rule.rs

@@ -68,7 +68,7 @@ impl Parse for SingleValue {
 
 impl ToCss for SingleValue {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        write!(dest, "{}", self.0)
+        self.0.to_css(dest)
     }
 }
 
@@ -105,9 +105,10 @@ impl Parse for PairValues {
 
 impl ToCss for PairValues {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        write!(dest, "{}", self.0)?;
+        self.0.to_css(dest)?;
         if let Some(second) = self.1 {
-            write!(dest, " {}", second)?;
+            dest.write_char(' ')?;
+            second.to_css(dest)?;
         }
         Ok(())
     }
@@ -158,10 +159,10 @@ impl ToCss for VectorValues {
         let mut iter = self.0.iter();
         let first = iter.next();
         if let Some(first) = first {
-            write!(dest, "{}", first)?;
+            first.to_css(dest)?;
             for value in iter {
-                dest.write_str(" ")?;
-                write!(dest, "{}", value)?;
+                dest.write_char(' ')?;
+                value.to_css(dest)?;
             }
         }
         Ok(())

components/style/stylesheets/keyframes_rule.rs

@@ -155,7 +155,7 @@ impl ToCss for KeyframeSelector {
         let mut iter = self.0.iter();
         iter.next().unwrap().to_css(dest)?;
         for percentage in iter {
-            write!(dest, ", ")?;
+            dest.write_str(", ")?;
             percentage.to_css(dest)?;
         }
         Ok(())

components/style/stylesheets/viewport_rule.rs

@@ -151,7 +151,7 @@ impl ToCss for ViewportLength {
     {
         match *self {
             ViewportLength::Specified(ref length) => length.to_css(dest),
-            ViewportLength::ExtendToZoom => write!(dest, "extend-to-zoom"),
+            ViewportLength::ExtendToZoom => dest.write_str("extend-to-zoom"),
         }
     }
 }

components/style/values/generics/mod.rs

@@ -226,7 +226,10 @@ impl ToCss for FontSettingTagInt {
         match self.0 {
             1 => Ok(()),
             0 => dest.write_str(" off"),
-            x => write!(dest, " {}", x)
+            x => {
+                dest.write_char(' ')?;
+                x.to_css(dest)
+            }
         }
     }
 }

components/style/values/specified/length.rs

@@ -424,7 +424,11 @@ impl ToCss for NoCalcLength {
             NoCalcLength::FontRelative(length) => length.to_css(dest),
             NoCalcLength::ViewportPercentage(length) => length.to_css(dest),
             /* This should only be reached from style dumping code */
-            NoCalcLength::ServoCharacterWidth(CharacterWidth(i)) => write!(dest, "CharWidth({})", i),
+            NoCalcLength::ServoCharacterWidth(CharacterWidth(i)) => {
+                dest.write_str("CharWidth(")?;
+                i.to_css(dest)?;
+                dest.write_char(')')
+            }
             #[cfg(feature = "gecko")]
             NoCalcLength::Physical(length) => length.to_css(dest),
         }