diff --git a/components/style/values/computed/transform.rs b/components/style/values/computed/transform.rs
index dc5f6de17e1..3be9816b34c 100644
--- a/components/style/values/computed/transform.rs
+++ b/components/style/values/computed/transform.rs
@@ -17,8 +17,15 @@ use values::generics::transform::TimingFunction as GenericTimingFunction;
 use values::generics::transform::TransformOrigin as GenericTransformOrigin;
 
 /// A single operation in a computed CSS `transform`
-pub type TransformOperation = GenericTransformOperation<Angle, Number, Length, Integer,
-                                                        LengthOrNumber, LengthOrPercentage, LengthOrPercentageOrNumber>;
+pub type TransformOperation = GenericTransformOperation<
+    Angle,
+    Number,
+    Length,
+    Integer,
+    LengthOrNumber,
+    LengthOrPercentage,
+    LengthOrPercentageOrNumber,
+>;
 /// A computed CSS `transform`
 pub type Transform = GenericTransform<TransformOperation>;
 
@@ -52,6 +59,7 @@ pub type Matrix = GenericMatrix<Number>;
 /// computed value of matrix() in -moz-transform
 pub type PrefixedMatrix = GenericMatrix<Number, LengthOrPercentageOrNumber>;
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl Matrix3D {
     #[inline]
     /// Get an identity matrix
@@ -81,6 +89,7 @@ impl Matrix3D {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl PrefixedMatrix3D {
     #[inline]
     /// Get an identity matrix
@@ -95,6 +104,7 @@ impl PrefixedMatrix3D {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl Matrix {
     #[inline]
     /// Get an identity matrix
@@ -108,6 +118,7 @@ impl Matrix {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl From<Matrix> for Matrix3D {
     fn from(m: Matrix) -> Self {
         Self {
@@ -119,6 +130,7 @@ impl From<Matrix> for Matrix3D {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl PrefixedMatrix {
     #[inline]
     /// Get an identity matrix
@@ -132,6 +144,7 @@ impl PrefixedMatrix {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl From<Matrix3D> for Transform3D<CSSFloat> {
     #[inline]
     fn from(m: Matrix3D) -> Self {
@@ -143,6 +156,7 @@ impl From<Matrix3D> for Transform3D<CSSFloat> {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl From<Transform3D<CSSFloat>> for Matrix3D {
     #[inline]
     fn from(m: Transform3D<CSSFloat>) -> Self {
@@ -155,6 +169,7 @@ impl From<Transform3D<CSSFloat>> for Matrix3D {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl From<Matrix> for Transform3D<CSSFloat> {
     #[inline]
     fn from(m: Matrix) -> Self {
@@ -174,16 +189,23 @@ impl TransformOperation {
         match *self {
             GenericTransformOperation::Translate3D(..) => self.clone(),
             GenericTransformOperation::TranslateX(ref x) |
-            GenericTransformOperation::Translate(ref x, None) =>
-                GenericTransformOperation::Translate3D(x.clone(), LengthOrPercentage::zero(), Length::zero()),
-            GenericTransformOperation::Translate(ref x, Some(ref y)) =>
-                GenericTransformOperation::Translate3D(x.clone(), y.clone(), Length::zero()),
-            GenericTransformOperation::TranslateY(ref y) =>
-                GenericTransformOperation::Translate3D(LengthOrPercentage::zero(), y.clone(), Length::zero()),
-            GenericTransformOperation::TranslateZ(ref z) =>
-                GenericTransformOperation::Translate3D(LengthOrPercentage::zero(),
-                                                       LengthOrPercentage::zero(), z.clone()),
-            _ => unreachable!()
+            GenericTransformOperation::Translate(ref x, None) => {
+                GenericTransformOperation::Translate3D(x.clone(), LengthOrPercentage::zero(), Length::zero())
+            },
+            GenericTransformOperation::Translate(ref x, Some(ref y)) => {
+                GenericTransformOperation::Translate3D(x.clone(), y.clone(), Length::zero())
+            },
+            GenericTransformOperation::TranslateY(ref y) => {
+                GenericTransformOperation::Translate3D(LengthOrPercentage::zero(), y.clone(), Length::zero())
+            },
+            GenericTransformOperation::TranslateZ(ref z) => {
+                GenericTransformOperation::Translate3D(
+                    LengthOrPercentage::zero(),
+                    LengthOrPercentage::zero(),
+                    z.clone(),
+                )
+            },
+            _ => unreachable!(),
         }
     }
     /// Convert to a Scale3D.
@@ -197,7 +219,7 @@ impl TransformOperation {
             GenericTransformOperation::ScaleX(x) => GenericTransformOperation::Scale3D(x, 1., 1.),
             GenericTransformOperation::ScaleY(y) => GenericTransformOperation::Scale3D(1., y, 1.),
             GenericTransformOperation::ScaleZ(z) => GenericTransformOperation::Scale3D(1., 1., z),
-            _ => unreachable!()
+            _ => unreachable!(),
         }
     }
 }
@@ -208,17 +230,17 @@ impl TransformOperation {
 impl ToAnimatedZero for TransformOperation {
     fn to_animated_zero(&self) -> Result<Self, ()> {
         match *self {
-            GenericTransformOperation::Matrix3D(..) => {
-                Ok(GenericTransformOperation::Matrix3D(Matrix3D::identity()))
-            },
+            GenericTransformOperation::Matrix3D(..) => Ok(GenericTransformOperation::Matrix3D(Matrix3D::identity())),
             GenericTransformOperation::PrefixedMatrix3D(..) => {
-                Ok(GenericTransformOperation::PrefixedMatrix3D(PrefixedMatrix3D::identity()))
-            },
-            GenericTransformOperation::Matrix(..) => {
-                Ok(GenericTransformOperation::Matrix(Matrix::identity()))
+                Ok(GenericTransformOperation::PrefixedMatrix3D(
+                    PrefixedMatrix3D::identity(),
+                ))
             },
+            GenericTransformOperation::Matrix(..) => Ok(GenericTransformOperation::Matrix(Matrix::identity())),
             GenericTransformOperation::PrefixedMatrix(..) => {
-                Ok(GenericTransformOperation::PrefixedMatrix(PrefixedMatrix::identity()))
+                Ok(GenericTransformOperation::PrefixedMatrix(
+                    PrefixedMatrix::identity(),
+                ))
             },
             GenericTransformOperation::Skew(sx, sy) => {
                 Ok(GenericTransformOperation::Skew(
@@ -226,16 +248,8 @@ impl ToAnimatedZero for TransformOperation {
                     sy.to_animated_zero()?,
                 ))
             },
-            GenericTransformOperation::SkewX(s) => {
-                Ok(GenericTransformOperation::SkewX(
-                    s.to_animated_zero()?,
-                ))
-            },
-            GenericTransformOperation::SkewY(s) => {
-                Ok(GenericTransformOperation::SkewY(
-                    s.to_animated_zero()?,
-                ))
-            },
+            GenericTransformOperation::SkewX(s) => Ok(GenericTransformOperation::SkewX(s.to_animated_zero()?)),
+            GenericTransformOperation::SkewY(s) => Ok(GenericTransformOperation::SkewY(s.to_animated_zero()?)),
             GenericTransformOperation::Translate3D(ref tx, ref ty, ref tz) => {
                 Ok(GenericTransformOperation::Translate3D(
                     tx.to_animated_zero()?,
@@ -250,54 +264,34 @@ impl ToAnimatedZero for TransformOperation {
                 ))
             },
             GenericTransformOperation::TranslateX(ref t) => {
-                Ok(GenericTransformOperation::TranslateX(
-                    t.to_animated_zero()?,
-                ))
+                Ok(GenericTransformOperation::TranslateX(t.to_animated_zero()?))
             },
             GenericTransformOperation::TranslateY(ref t) => {
-                Ok(GenericTransformOperation::TranslateY(
-                    t.to_animated_zero()?,
-                ))
+                Ok(GenericTransformOperation::TranslateY(t.to_animated_zero()?))
             },
             GenericTransformOperation::TranslateZ(ref t) => {
-                Ok(GenericTransformOperation::TranslateZ(
-                    t.to_animated_zero()?,
-                ))
-            },
-            GenericTransformOperation::Scale3D(..) => {
-                Ok(GenericTransformOperation::Scale3D(1.0, 1.0, 1.0))
-            },
-            GenericTransformOperation::Scale(_, _) => {
-                Ok(GenericTransformOperation::Scale(1.0, Some(1.0)))
-            },
-            GenericTransformOperation::ScaleX(..) => {
-                Ok(GenericTransformOperation::ScaleX(1.0))
-            },
-            GenericTransformOperation::ScaleY(..) => {
-                Ok(GenericTransformOperation::ScaleY(1.0))
-            },
-            GenericTransformOperation::ScaleZ(..) => {
-                Ok(GenericTransformOperation::ScaleZ(1.0))
+                Ok(GenericTransformOperation::TranslateZ(t.to_animated_zero()?))
             },
+            GenericTransformOperation::Scale3D(..) => Ok(GenericTransformOperation::Scale3D(1.0, 1.0, 1.0)),
+            GenericTransformOperation::Scale(_, _) => Ok(GenericTransformOperation::Scale(1.0, Some(1.0))),
+            GenericTransformOperation::ScaleX(..) => Ok(GenericTransformOperation::ScaleX(1.0)),
+            GenericTransformOperation::ScaleY(..) => Ok(GenericTransformOperation::ScaleY(1.0)),
+            GenericTransformOperation::ScaleZ(..) => Ok(GenericTransformOperation::ScaleZ(1.0)),
             GenericTransformOperation::Rotate3D(x, y, z, a) => {
                 let (x, y, z, _) = Transform::get_normalized_vector_and_angle(x, y, z, a);
                 Ok(GenericTransformOperation::Rotate3D(x, y, z, Angle::zero()))
             },
-            GenericTransformOperation::RotateX(_) => {
-                Ok(GenericTransformOperation::RotateX(Angle::zero()))
-            },
-            GenericTransformOperation::RotateY(_) => {
-                Ok(GenericTransformOperation::RotateY(Angle::zero()))
-            },
-            GenericTransformOperation::RotateZ(_) => {
-                Ok(GenericTransformOperation::RotateZ(Angle::zero()))
-            },
-            GenericTransformOperation::Rotate(_) => {
-                Ok(GenericTransformOperation::Rotate(Angle::zero()))
-            },
+            GenericTransformOperation::RotateX(_) => Ok(GenericTransformOperation::RotateX(Angle::zero())),
+            GenericTransformOperation::RotateY(_) => Ok(GenericTransformOperation::RotateY(Angle::zero())),
+            GenericTransformOperation::RotateZ(_) => Ok(GenericTransformOperation::RotateZ(Angle::zero())),
+            GenericTransformOperation::Rotate(_) => Ok(GenericTransformOperation::Rotate(Angle::zero())),
             GenericTransformOperation::Perspective(..) |
-            GenericTransformOperation::AccumulateMatrix { .. } |
-            GenericTransformOperation::InterpolateMatrix { .. } => {
+            GenericTransformOperation::AccumulateMatrix {
+                ..
+            } |
+            GenericTransformOperation::InterpolateMatrix {
+                ..
+            } => {
                 // Perspective: We convert a perspective function into an equivalent
                 //     ComputedMatrix, and then decompose/interpolate/recompose these matrices.
                 // AccumulateMatrix/InterpolateMatrix: We do interpolation on
@@ -316,9 +310,10 @@ impl ToAnimatedZero for TransformOperation {
 impl ToAnimatedZero for Transform {
     #[inline]
     fn to_animated_zero(&self) -> Result<Self, ()> {
-        Ok(GenericTransform(
-            self.0.iter().map(|op| op.to_animated_zero()).collect::<Result<Vec<_>, _>>()?
-        ))
+        Ok(GenericTransform(self.0
+            .iter()
+            .map(|op| op.to_animated_zero())
+            .collect::<Result<Vec<_>, _>>()?))
     }
 }
 
@@ -326,150 +321,131 @@ impl Transform {
     /// Return the equivalent 3d matrix of this transform list.
     /// If |reference_box| is None, we will drop the percent part from translate because
     /// we can resolve it without the layout info.
-    pub fn to_transform_3d_matrix(&self, reference_box: Option<&Rect<Au>>)
-                                  -> Option<Transform3D<CSSFloat>> {
+    pub fn to_transform_3d_matrix(&self, reference_box: Option<&Rect<Au>>) -> Option<Transform3D<CSSFloat>> {
         let mut transform = Transform3D::identity();
         let list = &self.0;
         if list.len() == 0 {
             return None;
         }
 
-        let extract_pixel_length = |lop: &LengthOrPercentage| {
-            match *lop {
-                LengthOrPercentage::Length(px) => px.px(),
-                LengthOrPercentage::Percentage(_) => 0.,
-                LengthOrPercentage::Calc(calc) => calc.length().px(),
-            }
+        let extract_pixel_length = |lop: &LengthOrPercentage| match *lop {
+            LengthOrPercentage::Length(px) => px.px(),
+            LengthOrPercentage::Percentage(_) => 0.,
+            LengthOrPercentage::Calc(calc) => calc.length().px(),
         };
 
         for operation in list {
             let matrix = match *operation {
                 GenericTransformOperation::Rotate3D(ax, ay, az, theta) => {
                     let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
-                    let (ax, ay, az, theta) =
-                        Self::get_normalized_vector_and_angle(ax, ay, az, theta);
+                    let (ax, ay, az, theta) = Self::get_normalized_vector_and_angle(ax, ay, az, theta);
                     Transform3D::create_rotation(ax, ay, az, theta.into())
-                }
+                },
                 GenericTransformOperation::RotateX(theta) => {
                     let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
                     Transform3D::create_rotation(1., 0., 0., theta.into())
-                }
+                },
                 GenericTransformOperation::RotateY(theta) => {
                     let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
                     Transform3D::create_rotation(0., 1., 0., theta.into())
-                }
-                GenericTransformOperation::RotateZ(theta) | GenericTransformOperation::Rotate(theta) => {
+                },
+                GenericTransformOperation::RotateZ(theta) |
+                GenericTransformOperation::Rotate(theta) => {
                     let theta = Angle::from_radians(2.0f32 * f32::consts::PI - theta.radians());
                     Transform3D::create_rotation(0., 0., 1., theta.into())
-                }
-                GenericTransformOperation::Perspective(d) => {
-                    Self::create_perspective_matrix(d.px())
-                }
-                GenericTransformOperation::Scale3D(sx, sy, sz) => {
-                    Transform3D::create_scale(sx, sy, sz)
-                }
-                GenericTransformOperation::Scale(sx, sy) => {
-                    Transform3D::create_scale(sx, sy.unwrap_or(sx), 1.)
-                }
-                GenericTransformOperation::ScaleX(s) => {
-                    Transform3D::create_scale(s, s, 1.)
-                }
-                GenericTransformOperation::ScaleY(s) => {
-                    Transform3D::create_scale(1., s, 1.)
-                }
-                GenericTransformOperation::ScaleZ(s) => {
-                    Transform3D::create_scale(1., 1., s)
-                }
+                },
+                GenericTransformOperation::Perspective(d) => Self::create_perspective_matrix(d.px()),
+                GenericTransformOperation::Scale3D(sx, sy, sz) => Transform3D::create_scale(sx, sy, sz),
+                GenericTransformOperation::Scale(sx, sy) => Transform3D::create_scale(sx, sy.unwrap_or(sx), 1.),
+                GenericTransformOperation::ScaleX(s) => Transform3D::create_scale(s, 1., 1.),
+                GenericTransformOperation::ScaleY(s) => Transform3D::create_scale(1., s, 1.),
+                GenericTransformOperation::ScaleZ(s) => Transform3D::create_scale(1., 1., s),
                 GenericTransformOperation::Translate3D(tx, ty, tz) => {
                     let (tx, ty) = match reference_box {
                         Some(relative_border_box) => {
-                            (tx.to_pixel_length(relative_border_box.size.width).px(),
-                             ty.to_pixel_length(relative_border_box.size.height).px())
+                            (
+                                tx.to_pixel_length(relative_border_box.size.width).px(),
+                                ty.to_pixel_length(relative_border_box.size.height).px(),
+                            )
                         },
                         None => {
                             // If we don't have reference box, we cannot resolve the used value,
                             // so only retrieve the length part. This will be used for computing
                             // distance without any layout info.
                             (extract_pixel_length(&tx), extract_pixel_length(&ty))
-                        }
+                        },
                     };
                     let tz = tz.px();
                     Transform3D::create_translation(tx, ty, tz)
-                }
+                },
                 GenericTransformOperation::Translate(tx, Some(ty)) => {
                     let (tx, ty) = match reference_box {
                         Some(relative_border_box) => {
-                            (tx.to_pixel_length(relative_border_box.size.width).px(),
-                             ty.to_pixel_length(relative_border_box.size.height).px())
+                            (
+                                tx.to_pixel_length(relative_border_box.size.width).px(),
+                                ty.to_pixel_length(relative_border_box.size.height).px(),
+                            )
                         },
                         None => {
                             // If we don't have reference box, we cannot resolve the used value,
                             // so only retrieve the length part. This will be used for computing
                             // distance without any layout info.
                             (extract_pixel_length(&tx), extract_pixel_length(&ty))
-                        }
+                        },
                     };
                     Transform3D::create_translation(tx, ty, 0.)
-                }
-                GenericTransformOperation::TranslateX(t) | GenericTransformOperation::Translate(t, None) => {
+                },
+                GenericTransformOperation::TranslateX(t) |
+                GenericTransformOperation::Translate(t, None) => {
                     let t = match reference_box {
-                        Some(relative_border_box) => {
-                            t.to_pixel_length(relative_border_box.size.width).px()
-                        },
+                        Some(relative_border_box) => t.to_pixel_length(relative_border_box.size.width).px(),
                         None => {
                             // If we don't have reference box, we cannot resolve the used value,
                             // so only retrieve the length part. This will be used for computing
                             // distance without any layout info.
                             extract_pixel_length(&t)
-                        }
+                        },
                     };
                     Transform3D::create_translation(t, 0., 0.)
-                }
+                },
                 GenericTransformOperation::TranslateY(t) => {
                     let t = match reference_box {
-                        Some(relative_border_box) => {
-                            t.to_pixel_length(relative_border_box.size.height).px()
-                        },
+                        Some(relative_border_box) => t.to_pixel_length(relative_border_box.size.height).px(),
                         None => {
                             // If we don't have reference box, we cannot resolve the used value,
                             // so only retrieve the length part. This will be used for computing
                             // distance without any layout info.
                             extract_pixel_length(&t)
-                        }
+                        },
                     };
                     Transform3D::create_translation(0., t, 0.)
-                }
-                GenericTransformOperation::TranslateZ(z) => {
-                    Transform3D::create_translation(0., 0., z.px())
-                }
+                },
+                GenericTransformOperation::TranslateZ(z) => Transform3D::create_translation(0., 0., z.px()),
                 GenericTransformOperation::Skew(theta_x, theta_y) => {
                     Transform3D::create_skew(theta_x.into(), theta_y.unwrap_or(Angle::zero()).into())
-                }
-                GenericTransformOperation::SkewX(theta) => {
-                    Transform3D::create_skew(theta.into(), Angle::zero().into())
-                }
-                GenericTransformOperation::SkewY(theta) => {
-                    Transform3D::create_skew(Angle::zero().into(), theta.into())
-                }
-                GenericTransformOperation::Matrix3D(m) => {
-                    m.into()
-                }
-                GenericTransformOperation::Matrix(m) => {
-                    m.into()
-                }
-                GenericTransformOperation::PrefixedMatrix3D(_) | GenericTransformOperation::PrefixedMatrix(_) => {
+                },
+                GenericTransformOperation::SkewX(theta) => Transform3D::create_skew(theta.into(), Angle::zero().into()),
+                GenericTransformOperation::SkewY(theta) => Transform3D::create_skew(Angle::zero().into(), theta.into()),
+                GenericTransformOperation::Matrix3D(m) => m.into(),
+                GenericTransformOperation::Matrix(m) => m.into(),
+                GenericTransformOperation::PrefixedMatrix3D(_) |
+                GenericTransformOperation::PrefixedMatrix(_) => {
                     // `-moz-transform` is not implemented in Servo yet.
                     unreachable!()
-                }
-                GenericTransformOperation::InterpolateMatrix { .. } |
-                GenericTransformOperation::AccumulateMatrix { .. } => {
+                },
+                GenericTransformOperation::InterpolateMatrix {
+                    ..
+                } |
+                GenericTransformOperation::AccumulateMatrix {
+                    ..
+                } => {
                     // TODO: Convert InterpolateMatrix/AccmulateMatrix into a valid Transform3D by
                     // the reference box and do interpolation on these two Transform3D matrices.
                     // Both Gecko and Servo don't support this for computing distance, and Servo
                     // doesn't support animations on InterpolateMatrix/AccumulateMatrix, so
                     // return None.
                     return None;
-                }
+                },
             };
 
             transform = transform.pre_mul(&matrix);
@@ -496,8 +472,7 @@ impl Transform {
     }
 
     /// Return the normalized direction vector and its angle for Rotate3D.
-    pub fn get_normalized_vector_and_angle(x: f32, y: f32, z: f32, angle: Angle)
-                                           -> (f32, f32, f32, Angle) {
+    pub fn get_normalized_vector_and_angle(x: f32, y: f32, z: f32, angle: Angle) -> (f32, f32, f32, Angle) {
         use euclid::approxeq::ApproxEq;
         use euclid::num::Zero;
         let vector = DirectionVector::new(x, y, z);
diff --git a/components/style/values/generics/transform.rs b/components/style/values/generics/transform.rs
index 2bbf641b834..45d19c8ab68 100644
--- a/components/style/values/generics/transform.rs
+++ b/components/style/values/generics/transform.rs
@@ -22,6 +22,7 @@ pub struct Matrix<T, U = T> {
 }
 
 #[allow(missing_docs)]
+#[cfg_attr(rustfmt, rustfmt_skip)]
 #[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
 pub struct Matrix3D<T, U = T, V = T> {
     pub m11: T, pub m12: T, pub m13: T, pub m14: T,
@@ -51,7 +52,12 @@ pub enum TimingFunction<Integer, Number> {
     Keyword(TimingKeyword),
     /// `cubic-bezier(<number>, <number>, <number>, <number>)`
     #[allow(missing_docs)]
-    CubicBezier { x1: Number, y1: Number, x2: Number, y2: Number },
+    CubicBezier {
+        x1: Number,
+        y1: Number,
+        x2: Number,
+        y2: Number,
+    },
     /// `step-start | step-end | steps(<integer>, [ start | end ]?)`
     Steps(Integer, StepPosition),
     /// `frames(<integer>)`
@@ -103,7 +109,12 @@ where
     {
         match *self {
             TimingFunction::Keyword(keyword) => keyword.to_css(dest),
-            TimingFunction::CubicBezier { ref x1, ref y1, ref x2, ref y2 } => {
+            TimingFunction::CubicBezier {
+                ref x1,
+                ref y1,
+                ref x2,
+                ref y2,
+            } => {
                 dest.write_str("cubic-bezier(")?;
                 x1.to_css(dest)?;
                 dest.write_str(", ")?;
@@ -223,23 +234,63 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrNumber, Leng
     Perspective(Length),
     /// A intermediate type for interpolation of mismatched transform lists.
     #[allow(missing_docs)]
-    InterpolateMatrix { #[compute(ignore_bound)]
-                        from_list: Transform<TransformOperation<Angle, Number, Length, Integer,
-                                                                LengthOrNumber, LengthOrPercentage, LoPoNumber>>,
-                        #[compute(ignore_bound)]
-                        to_list: Transform<TransformOperation<Angle, Number, Length, Integer,
-                                                              LengthOrNumber, LengthOrPercentage, LoPoNumber>>,
-                        #[compute(clone)] progress: computed::Percentage },
+    InterpolateMatrix {
+        #[compute(ignore_bound)]
+        from_list: Transform<
+            TransformOperation<
+                Angle,
+                Number,
+                Length,
+                Integer,
+                LengthOrNumber,
+                LengthOrPercentage,
+                LoPoNumber,
+            >,
+        >,
+        #[compute(ignore_bound)]
+        to_list: Transform<
+            TransformOperation<
+                Angle,
+                Number,
+                Length,
+                Integer,
+                LengthOrNumber,
+                LengthOrPercentage,
+                LoPoNumber,
+            >,
+        >,
+        #[compute(clone)]
+        progress: computed::Percentage,
+    },
     /// A intermediate type for accumulation of mismatched transform lists.
     #[allow(missing_docs)]
-
-    AccumulateMatrix { #[compute(ignore_bound)]
-                       from_list: Transform<TransformOperation<Angle, Number, Length, Integer,
-                                                               LengthOrNumber, LengthOrPercentage, LoPoNumber>>,
-                       #[compute(ignore_bound)]
-                       to_list: Transform<TransformOperation<Angle, Number, Length, Integer,
-                                                             LengthOrNumber, LengthOrPercentage, LoPoNumber>>,
-                       count: Integer },
+    AccumulateMatrix {
+        #[compute(ignore_bound)]
+        from_list: Transform<
+            TransformOperation<
+                Angle,
+                Number,
+                Length,
+                Integer,
+                LengthOrNumber,
+                LengthOrPercentage,
+                LoPoNumber,
+            >,
+        >,
+        #[compute(ignore_bound)]
+        to_list: Transform<
+            TransformOperation<
+                Angle,
+                Number,
+                Length,
+                Integer,
+                LengthOrNumber,
+                LengthOrPercentage,
+                LoPoNumber,
+            >,
+        >,
+        count: Integer,
+    },
 }
 
 #[derive(Animate, ToComputedValue)]
@@ -254,7 +305,7 @@ impl<Angle, Number, Length, Integer, LengthOrNumber, LengthOrPercentage, LoPoNum
         use self::TransformOperation::*;
         match *self {
             Translate(..) | Translate3D(..) | TranslateX(..) | TranslateY(..) | TranslateZ(..) => true,
-            _ => false
+            _ => false,
         }
     }
 
@@ -263,11 +314,12 @@ impl<Angle, Number, Length, Integer, LengthOrNumber, LengthOrPercentage, LoPoNum
         use self::TransformOperation::*;
         match *self {
             Scale(..) | Scale3D(..) | ScaleX(..) | ScaleY(..) | ScaleZ(..) => true,
-            _ => false
+            _ => false,
         }
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 impl<Angle: ToCss + Copy, Number: ToCss + Copy, Length: ToCss,
      Integer: ToCss + Copy, LengthOrNumber: ToCss, LengthOrPercentage: ToCss, LoPoNumber: ToCss>
     ToCss for
@@ -379,9 +431,12 @@ impl<Angle: ToCss + Copy, Number: ToCss + Copy, Length: ToCss,
 }
 
 impl<T: ToCss> ToCss for Transform<T> {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
         if self.0.is_empty() {
-            return dest.write_str("none")
+            return dest.write_str("none");
         }
 
         let mut first = true;
diff --git a/components/style/values/specified/transform.rs b/components/style/values/specified/transform.rs
index 14bd00a1af5..e01a5d996c5 100644
--- a/components/style/values/specified/transform.rs
+++ b/components/style/values/specified/transform.rs
@@ -20,8 +20,15 @@ use values::specified::{LengthOrNumber, LengthOrPercentage, LengthOrPercentageOr
 use values::specified::position::{Side, X, Y};
 
 /// A single operation in a specified CSS `transform`
-pub type TransformOperation = GenericTransformOperation<Angle, Number, Length, Integer,
-                                                        LengthOrNumber, LengthOrPercentage, LengthOrPercentageOrNumber>;
+pub type TransformOperation = GenericTransformOperation<
+    Angle,
+    Number,
+    Length,
+    Integer,
+    LengthOrNumber,
+    LengthOrPercentage,
+    LengthOrPercentageOrNumber,
+>;
 /// A specified CSS `transform`
 pub type Transform = GenericTransform<TransformOperation>;
 
@@ -39,15 +46,19 @@ impl Transform {
     ) -> Result<Self, ParseError<'i>> {
         use style_traits::{Separator, Space};
 
-        if input.try(|input| input.expect_ident_matching("none")).is_ok() {
-            return Ok(GenericTransform(Vec::new()))
+        if input
+            .try(|input| input.expect_ident_matching("none"))
+            .is_ok()
+        {
+            return Ok(GenericTransform(Vec::new()));
         }
 
         Ok(GenericTransform(Space::parse(input, |input| {
             let function = input.expect_function()?.clone();
             input.parse_nested_block(|input| {
                 let location = input.current_source_location();
-                let result = match_ignore_ascii_case! { &function,
+                let result =
+                    match_ignore_ascii_case! { &function,
                     "matrix" => {
                         let a = specified::parse_number(context, input)?;
                         input.expect_comma()?;
@@ -260,7 +271,9 @@ pub type TimingFunction = GenericTimingFunction<Integer, Number>;
 impl Parse for TransformOrigin {
     fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
         let parse_depth = |input: &mut Parser| {
-            input.try(|i| Length::parse(context, i)).unwrap_or(Length::from_px(0.))
+            input.try(|i| Length::parse(context, i)).unwrap_or(
+                Length::from_px(0.),
+            )
         };
         match input.try(|i| OriginComponent::parse(context, i)) {
             Ok(x_origin @ OriginComponent::Center) => {
@@ -307,7 +320,8 @@ impl Parse for TransformOrigin {
 }
 
 impl<S> Parse for OriginComponent<S>
-    where S: Parse,
+where
+    S: Parse,
 {
     fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
         if input.try(|i| i.expect_ident_matching("center")).is_ok() {
@@ -322,18 +336,15 @@ impl<S> Parse for OriginComponent<S>
 }
 
 impl<S> ToComputedValue for OriginComponent<S>
-    where S: Side,
+where
+    S: Side,
 {
     type ComputedValue = ComputedLengthOrPercentage;
 
     fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
         match *self {
-            OriginComponent::Center => {
-                ComputedLengthOrPercentage::Percentage(ComputedPercentage(0.5))
-            },
-            OriginComponent::Length(ref length) => {
-                length.to_computed_value(context)
-            },
+            OriginComponent::Center => ComputedLengthOrPercentage::Percentage(ComputedPercentage(0.5)),
+            OriginComponent::Length(ref length) => length.to_computed_value(context),
             OriginComponent::Side(ref keyword) => {
                 let p = ComputedPercentage(if keyword.is_start() { 0. } else { 1. });
                 ComputedLengthOrPercentage::Percentage(p)
@@ -362,7 +373,9 @@ fn allow_frames_timing() -> bool {
 
 #[cfg(feature = "servo")]
 #[inline]
-fn allow_frames_timing() -> bool { true }
+fn allow_frames_timing() -> bool {
+    true
+}
 
 impl Parse for TimingFunction {
     fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
@@ -370,7 +383,8 @@ impl Parse for TimingFunction {
             return Ok(GenericTimingFunction::Keyword(keyword));
         }
         if let Ok(ident) = input.try(|i| i.expect_ident_cloned()) {
-            let position = match_ignore_ascii_case! { &ident,
+            let position =
+                match_ignore_ascii_case! { &ident,
                 "step-start" => StepPosition::Start,
                 "step-end" => StepPosition::End,
                 _ => return Err(input.new_custom_error(SelectorParseErrorKind::UnexpectedIdent(ident.clone()))),
@@ -424,10 +438,13 @@ impl ToComputedValue for TimingFunction {
     #[inline]
     fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
         match *self {
-            GenericTimingFunction::Keyword(keyword) => {
-                GenericTimingFunction::Keyword(keyword)
-            },
-            GenericTimingFunction::CubicBezier { x1, y1, x2, y2 } => {
+            GenericTimingFunction::Keyword(keyword) => GenericTimingFunction::Keyword(keyword),
+            GenericTimingFunction::CubicBezier {
+                x1,
+                y1,
+                x2,
+                y2,
+            } => {
                 GenericTimingFunction::CubicBezier {
                     x1: x1.to_computed_value(context),
                     y1: y1.to_computed_value(context),
@@ -436,15 +453,10 @@ impl ToComputedValue for TimingFunction {
                 }
             },
             GenericTimingFunction::Steps(steps, position) => {
-                GenericTimingFunction::Steps(
-                    steps.to_computed_value(context) as u32,
-                    position,
-                )
+                GenericTimingFunction::Steps(steps.to_computed_value(context) as u32, position)
             },
             GenericTimingFunction::Frames(frames) => {
-                GenericTimingFunction::Frames(
-                    frames.to_computed_value(context) as u32,
-                )
+                GenericTimingFunction::Frames(frames.to_computed_value(context) as u32)
             },
         }
     }
@@ -452,10 +464,13 @@ impl ToComputedValue for TimingFunction {
     #[inline]
     fn from_computed_value(computed: &Self::ComputedValue) -> Self {
         match *computed {
-            GenericTimingFunction::Keyword(keyword) => {
-                GenericTimingFunction::Keyword(keyword)
-            },
-            GenericTimingFunction::CubicBezier { ref x1, ref y1, ref x2, ref y2 } => {
+            GenericTimingFunction::Keyword(keyword) => GenericTimingFunction::Keyword(keyword),
+            GenericTimingFunction::CubicBezier {
+                ref x1,
+                ref y1,
+                ref x2,
+                ref y2,
+            } => {
                 GenericTimingFunction::CubicBezier {
                     x1: Number::from_computed_value(x1),
                     y1: Number::from_computed_value(y1),
@@ -464,15 +479,10 @@ impl ToComputedValue for TimingFunction {
                 }
             },
             GenericTimingFunction::Steps(steps, position) => {
-                GenericTimingFunction::Steps(
-                    Integer::from_computed_value(&(steps as i32)),
-                    position,
-                )
+                GenericTimingFunction::Steps(Integer::from_computed_value(&(steps as i32)), position)
             },
             GenericTimingFunction::Frames(frames) => {
-                GenericTimingFunction::Frames(
-                    Integer::from_computed_value(&(frames as i32)),
-                )
+                GenericTimingFunction::Frames(Integer::from_computed_value(&(frames as i32)))
             },
         }
     }