Merge similar arms in AnimationValue::compute_squared_distance 🐉🐲

This uses the same trick as in PropertyDeclaration::eq.

components/style/properties/helpers/animated_properties.mako.rs

@@ -564,17 +564,17 @@ fn animate_discrete<T: Clone>(this: &T, other: &T, procedure: Procedure) -> Resu
     }
 }
 
-impl Animate for AnimationValue {
-    fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
-        use self::AnimationValue::*;
-
-        Ok(unsafe {
 #[repr(C)]
 struct AnimationValueVariantRepr<T> {
     tag: u16,
     value: T
 }
 
+impl Animate for AnimationValue {
+    fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
+        Ok(unsafe {
+            use self::AnimationValue::*;
+
             let this_tag = *(self as *const _ as *const u16);
             let other_tag = *(other as *const _ as *const u16);
             if this_tag != other_tag {
@@ -612,31 +612,35 @@ impl Animate for AnimationValue {
     }
 }
 
+<%
+    nondiscrete = []
+    for prop in animated:
+        if prop.animation_value_type != "discrete":
+            nondiscrete.append(prop)
+%>
+
 impl ComputeSquaredDistance for AnimationValue {
     fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
-        match *self {
+        unsafe {
-            % for i, prop in enumerate([p for p in data.longhands if p.animatable and p.animation_value_type == "discrete"]):
+            use self::AnimationValue::*;
-            % if i > 0:
+
-            |
+            let this_tag = *(self as *const _ as *const u16);
-            % endif
+            let other_tag = *(other as *const _ as *const u16);
-            AnimationValue::${prop.camel_case}(..)
+            if this_tag != other_tag {
-            % endfor
+                panic!("Unexpected AnimationValue::compute_squared_distance call");
-            => return Err(()),
+            }
-            _ => (),
+
+            match *self {
+                % for ty, props in groupby(nondiscrete, key=lambda x: x.animated_type()):
+                ${" |\n".join("{}(ref this)".format(prop.camel_case) for prop in props)} => {
+                    let other_repr =
+                        &*(other as *const _ as *const AnimationValueVariantRepr<${ty}>);
+
+                    this.compute_squared_distance(&other_repr.value)
                 }
-        match (self, other) {
-            % for prop in data.longhands:
-            % if prop.animatable:
-            % if prop.animation_value_type != "discrete":
-            (&AnimationValue::${prop.camel_case}(ref this), &AnimationValue::${prop.camel_case}(ref other)) => {
-                this.compute_squared_distance(other)
-            },
-            % endif
-            % endif
                 % endfor
-            _ => {
+                _ => Err(()),
-                panic!("computed values should be of the same property");
+            }
-            },
         }
     }
 }