Remove usage of write! in components/style/properties/longhand/box.mako.rs

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;
 
@@ -821,13 +820,12 @@ ${helpers.predefined_type(
                     m31, m32, m33, m34,
                     m41, m42, m43, m44,
                 } => {
-                    write!(
+                    serialize_function!(dest, matrix3d(
-                        dest, "matrix3d({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {})",
+                        m11, m12, m13, m14,
-                        Css(m11), Css(m12), Css(m13), Css(m14),
+                        m21, m22, m23, m24,
-                        Css(m21), Css(m22), Css(m23), Css(m24),
+                        m31, m32, m33, m34,
-                        Css(m31), Css(m32), Css(m33), Css(m34),
+                        m41, m42, m43, m44,
-                        Css(m41), Css(m42), Css(m43), Css(m44),
+                    ))
-                    )
                 }
                 SpecifiedOperation::PrefixedMatrix3D {
                     m11, m12, m13, m14,
@@ -835,87 +833,84 @@ ${helpers.predefined_type(
                     m31, m32, m33, m34,
                     ref m41, ref m42, ref m43, m44,
                 } => {
-                    write!(
+                    serialize_function!(dest, matrix3d(
-                        dest, "matrix3d({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {})",
+                        m11, m12, m13, m14,
-                        Css(m11), Css(m12), Css(m13), Css(m14),
+                        m21, m22, m23, m24,
-                        Css(m21), Css(m22), Css(m23), Css(m24),
+                        m31, m32, m33, m34,
-                        Css(m31), Css(m32), Css(m33), Css(m34),
+                        m41, m42, m43, m44,
-                        Css(m41), Css(m42), Css(m43), Css(m44),
+                    ))
-                    )
                 }
                 SpecifiedOperation::Skew(ax, None) => {
-                    write!(dest, "skew({})", Css(ax))
+                    serialize_function!(dest, skew(ax))
                 }
                 SpecifiedOperation::Skew(ax, Some(ay)) => {
-                    write!(dest, "skew({}, {})", Css(ax), Css(ay))
+                    serialize_function!(dest, skew(ax, ay))
                 }
                 SpecifiedOperation::SkewX(angle) => {
-                    write!(dest, "skewX({})", Css(angle))
+                    serialize_function!(dest, skewX(angle))
                 }
                 SpecifiedOperation::SkewY(angle) => {
-                    write!(dest, "skewY({})", Css(angle))
+                    serialize_function!(dest, skewY(angle))
                 }
                 SpecifiedOperation::Translate(ref tx, None) => {
-                    write!(dest, "translate({})", Css(tx))
+                    serialize_function!(dest, translate(tx))
                 }
                 SpecifiedOperation::Translate(ref tx, Some(ref ty)) => {
-                    write!(dest, "translate({}, {})", Css(tx), Css(ty))
+                    serialize_function!(dest, translate(tx, ty))
                 }
                 SpecifiedOperation::TranslateX(ref tx) => {
-                    write!(dest, "translateX({})", Css(tx))
+                    serialize_function!(dest, translateX(tx))
                 }
                 SpecifiedOperation::TranslateY(ref ty) => {
-                    write!(dest, "translateY({})", Css(ty))
+                    serialize_function!(dest, translateY(ty))
                 }
                 SpecifiedOperation::TranslateZ(ref tz) => {
-                    write!(dest, "translateZ({})", Css(tz))
+                    serialize_function!(dest, translateZ(tz))
                 }
                 SpecifiedOperation::Translate3D(ref tx, ref ty, ref tz) => {
-                    write!(dest, "translate3d({}, {}, {})", Css(tx), Css(ty), Css(tz))
+                    serialize_function!(dest, translate3d(tx, ty, tz))
                 }
                 SpecifiedOperation::Scale(factor, None) => {
-                    write!(dest, "scale({})", Css(factor))
+                    serialize_function!(dest, scale(factor))
                 }
                 SpecifiedOperation::Scale(sx, Some(sy)) => {
-                    write!(dest, "scale({}, {})", Css(sx), Css(sy))
+                    serialize_function!(dest, scale(sx, sy))
                 }
                 SpecifiedOperation::ScaleX(sx) => {
-                    write!(dest, "scaleX({})", Css(sx))
+                    serialize_function!(dest, scaleX(sx))
                 }
                 SpecifiedOperation::ScaleY(sy) => {
-                    write!(dest, "scaleY({})", Css(sy))
+                    serialize_function!(dest, scaleY(sy))
                 }
                 SpecifiedOperation::ScaleZ(sz) => {
-                    write!(dest, "scaleZ({})", Css(sz))
+                    serialize_function!(dest, scaleZ(sz))
                 }
                 SpecifiedOperation::Scale3D(sx, sy, sz) => {
-                    write!(dest, "scale3d({}, {}, {})", Css(sx), Css(sy), Css(sz))
+                    serialize_function!(dest, scale3d(sx, sy, sz))
                 }
                 SpecifiedOperation::Rotate(theta) => {
-                    write!(dest, "rotate({})", Css(theta))
+                    serialize_function!(dest, rotate(theta))
                 }
                 SpecifiedOperation::RotateX(theta) => {
-                    write!(dest, "rotateX({})", Css(theta))
+                    serialize_function!(dest, rotateX(theta))
                 }
                 SpecifiedOperation::RotateY(theta) => {
-                    write!(dest, "rotateY({})", Css(theta))
+                    serialize_function!(dest, rotateY(theta))
                 }
                 SpecifiedOperation::RotateZ(theta) => {
-                    write!(dest, "rotateZ({})", Css(theta))
+                    serialize_function!(dest, rotateZ(theta))
                 }
                 SpecifiedOperation::Rotate3D(x, y, z, theta) => {
-                    write!(dest, "rotate3d({}, {}, {}, {})", Css(x), Css(y), Css(z), Css(theta))
+                    serialize_function!(dest, rotate3d(x, y, z, theta))
                 }
                 SpecifiedOperation::Perspective(ref length) => {
-                    write!(dest, "perspective({})", Css(length))
+                    serialize_function!(dest, perspective(length))
                 }
                 SpecifiedOperation::InterpolateMatrix { ref from_list, ref to_list, progress } => {
-                    write!(dest, "interpolatematrix({}, {}, {})",
+                    serialize_function!(dest, interpolatematrix(from_list, to_list, progress))
-                           Css(from_list), Css(to_list), Css(progress))
                 }
                 SpecifiedOperation::AccumulateMatrix { ref from_list, ref to_list, count } => {
-                    write!(dest, "accumulatematrix({}, {}, {})",
+                    serialize_function!(dest, accumulatematrix(from_list, to_list, count))
-                           Css(from_list), Css(to_list), Css(count))
                 }
             }
         }

components/style_traits/values.rs

@@ -70,6 +70,24 @@ where
     }
 }
 
+#[macro_export]
+macro_rules! serialize_function {
+    ($dest: expr, $name: ident($( $arg: expr, )+)) => {
+        serialize_function!($dest, $name($($arg),+))
+    };
+    ($dest: expr, $name: ident($first_arg: expr $( , $arg: expr )*)) => {
+        {
+            $dest.write_str(concat!(stringify!($name), "("))?;
+            $first_arg.to_css($dest)?;
+            $(
+                $dest.write_str(", ")?;
+                $arg.to_css($dest)?;
+            )*
+            $dest.write_char(')')
+        }
+    }
+}
+
 /// Convenience wrapper to serialise CSS values separated by a given string.
 pub struct SequenceWriter<'a, W> {
     writer: TrackedWriter<W>,
@@ -533,14 +551,3 @@ pub mod specified {
         }
     }
 }
-
-
-/// Wrap CSS types for serialization with `write!` or `format!` macros.
-/// Used by ToCss of SpecifiedOperation.
-pub struct Css<T>(pub T);
-
-impl<T: ToCss> fmt::Display for Css<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.to_css(f)
-    }
-}