Move some code to its own function in #[derive(Animate)]

components/style_derive/animate.rs

@@ -2,10 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use cg;
+use cg::{self, WhereClause};
 use quote::Tokens;
 use syn::{DeriveInput, Path};
-use synstructure;
+use synstructure::{Structure, VariantInfo};
 
 pub fn derive(input: DeriveInput) -> Tokens {
     let name = &input.ident;
@@ -14,15 +14,55 @@ pub fn derive(input: DeriveInput) -> Tokens {
         cg::trait_parts(&input, &trait_path);
 
     let input_attrs = cg::parse_input_attrs::<AnimateInputAttrs>(&input);
-    let s = synstructure::Structure::new(&input);
+    let s = Structure::new(&input);
     let mut append_error_clause = s.variants().len() > 1;
 
     let mut match_body = s.variants().iter().fold(quote!(), |body, variant| {
-        let variant_attrs = cg::parse_variant_attrs::<AnimationVariantAttrs>(&variant.ast());
+        let arm = match derive_variant_arm(variant, &mut where_clause) {
-        if variant_attrs.error {
+            Ok(arm) => arm,
+            Err(()) => {
                 append_error_clause = true;
                 return body;
             }
+        };
+        quote! { #body #arm }
+    });
+
+    if append_error_clause {
+        if let Some(fallback) = input_attrs.fallback {
+            match_body.append_all(quote! {
+                (this, other) => #fallback(this, other, procedure)
+            });
+        } else {
+            match_body.append_all(quote! { _ => Err(()) });
+        }
+    }
+
+    quote! {
+        impl #impl_generics ::values::animated::Animate for #name #ty_generics #where_clause {
+            #[allow(unused_variables, unused_imports)]
+            #[inline]
+            fn animate(
+                &self,
+                other: &Self,
+                procedure: ::values::animated::Procedure,
+            ) -> Result<Self, ()> {
+                match (self, other) {
+                    #match_body
+                }
+            }
+        }
+    }
+}
+
+fn derive_variant_arm(
+    variant: &VariantInfo,
+    where_clause: &mut WhereClause,
+) -> Result<Tokens, ()> {
+    let variant_attrs = cg::parse_variant_attrs::<AnimationVariantAttrs>(&variant.ast());
+    if variant_attrs.error {
+        return Err(());
+    }
     let (this_pattern, this_info) = cg::ref_pattern(&variant, "this");
     let (other_pattern, other_info) = cg::ref_pattern(&variant, "other");
     let (result_value, result_info) = cg::value(&variant, "result");
@@ -63,40 +103,12 @@ pub fn derive(input: DeriveInput) -> Tokens {
             }
         }
     }));
-        quote! {
+    Ok(quote! {
-            #body
         (&#this_pattern, &#other_pattern) => {
             #computations
             Ok(#result_value)
         }
-        }
+    })
-    });
-
-    if append_error_clause {
-        if let Some(fallback) = input_attrs.fallback {
-            match_body.append_all(quote! {
-                (this, other) => #fallback(this, other, procedure)
-            });
-        } else {
-            match_body.append_all(quote! { _ => Err(()) });
-        }
-    }
-
-    quote! {
-        impl #impl_generics ::values::animated::Animate for #name #ty_generics #where_clause {
-            #[allow(unused_variables, unused_imports)]
-            #[inline]
-            fn animate(
-                &self,
-                other: &Self,
-                procedure: ::values::animated::Procedure,
-            ) -> Result<Self, ()> {
-                match (self, other) {
-                    #match_body
-                }
-            }
-        }
-    }
 }
 
 #[darling(attributes(animate), default)]