Format in rfc style

.gitignore

@@ -1,3 +1,4 @@
-Cargo.lock
-target
+target/
+**/*.rs.bk
 *.sw[po]
+Cargo.lock

serde/src/de/impls.rs

@@ -1039,7 +1039,8 @@ impl<'de> Visitor<'de> for OsStringVisitor {
 
         match try!(data.variant()) {
             (OsStringKind::Windows, v) => {
-                v.newtype_variant::<Vec<u16>>().map(|vec| OsString::from_wide(&vec))
+                v.newtype_variant::<Vec<u16>>()
+                    .map(|vec| OsString::from_wide(&vec))
             }
             (OsStringKind::Unix, _) => Err(Error::custom("cannot deserialize Unix OS string on Windows",),),
         }
@@ -1151,7 +1152,7 @@ where
 
 impl<'de, T> Deserialize<'de> for RefCell<T>
 where
-    T: Deserialize<'de>
+    T: Deserialize<'de>,
 {
     fn deserialize<D>(deserializer: D) -> Result<RefCell<T>, D::Error>
     where

serde/src/de/value.rs

@@ -922,7 +922,8 @@ where
     Second<I::Item>: Debug,
 {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.debug_struct("MapDeserializer")
+        formatter
+            .debug_struct("MapDeserializer")
             .field("iter", &self.iter)
             .field("value", &self.value)
             .field("count", &self.count)

serde/src/private/de.rs

@@ -191,7 +191,8 @@ pub mod size_hint {
     use lib::*;
 
     pub fn from_bounds<I>(iter: &I) -> Option<usize>
-        where I: Iterator
+    where
+        I: Iterator,
     {
         helper(iter.size_hint())
     }
@@ -202,9 +203,7 @@ pub mod size_hint {
 
     fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
         match bounds {
-            (lower, Some(upper)) if lower == upper => {
-                Some(upper)
-            }
+            (lower, Some(upper)) if lower == upper => Some(upper),
             _ => None,
         }
     }
@@ -1026,10 +1025,7 @@ mod content {
         type Error = E;
         type Variant = VariantDeserializer<Self::Error>;
 
-        fn variant_seed<V>(
-            self,
-            seed: V,
-        ) -> Result<(V::Value, VariantDeserializer<E>), Self::Error>
+        fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E>
         where
             V: de::DeserializeSeed<'de>,
         {

serde_derive/src/bound.rs

@@ -169,7 +169,11 @@ where
     generics
 }
 
-pub fn with_self_bound(cont: &Container, generics: &syn::Generics, bound: &syn::Path) -> syn::Generics {
+pub fn with_self_bound(
+    cont: &Container,
+    generics: &syn::Generics,
+    bound: &syn::Path,
+) -> syn::Generics {
     let mut generics = generics.clone();
     generics
         .where_clause

serde_derive/src/de.rs

@@ -288,7 +288,7 @@ fn deserialize_tuple(
         None
     };
 
-    let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, false, cattrs),);
+    let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, false, cattrs));
 
     let visitor_expr = quote! {
         __Visitor {
@@ -488,7 +488,7 @@ fn deserialize_struct(
         None => format!("struct {}", params.type_name()),
     };
 
-    let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, true, cattrs),);
+    let visit_seq = Stmts(deserialize_seq(&type_path, params, fields, true, cattrs));
 
     let (field_visitor, fields_stmt, visit_map) =
         deserialize_struct_visitor(type_path, params, fields, cattrs);
@@ -618,23 +618,21 @@ fn deserialize_externally_tagged_enum(
     let variant_visitor = Stmts(deserialize_generated_identifier(variant_names_idents, cattrs, true),);
 
     // Match arms to extract a variant from a string
-    let variant_arms =
-        variants
-            .iter()
-            .enumerate()
-            .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-            .map(
-                |(i, variant)| {
-                    let variant_name = field_i(i);
+    let variant_arms = variants
+        .iter()
+        .enumerate()
+        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
+        .map(
+            |(i, variant)| {
+                let variant_name = field_i(i);
 
-                    let block =
-                        Match(deserialize_externally_tagged_variant(params, variant, cattrs),);
+                let block = Match(deserialize_externally_tagged_variant(params, variant, cattrs),);
 
-                    quote! {
+                quote! {
                 (__Field::#variant_name, __variant) => #block
             }
-                },
-            );
+            },
+        );
 
     let all_skipped = variants
         .iter()
@@ -1056,22 +1054,10 @@ fn deserialize_externally_tagged_variant(
             deserialize_externally_tagged_newtype_variant(variant_ident, params, &variant.fields[0])
         }
         Style::Tuple => {
-            deserialize_tuple(
-                Some(variant_ident),
-                params,
-                &variant.fields,
-                cattrs,
-                None,
-            )
+            deserialize_tuple(Some(variant_ident), params, &variant.fields, cattrs, None)
         }
         Style::Struct => {
-            deserialize_struct(
-                Some(variant_ident),
-                params,
-                &variant.fields,
-                cattrs,
-                None,
-            )
+            deserialize_struct(Some(variant_ident), params, &variant.fields, cattrs, None)
         }
     }
 }
@@ -1223,7 +1209,7 @@ fn deserialize_generated_identifier(
         (Some(ignore_variant), Some(fallthrough))
     };
 
-    let visitor_impl = Stmts(deserialize_identifier(this, &fields, is_variant, fallthrough));
+    let visitor_impl = Stmts(deserialize_identifier(this, &fields, is_variant, fallthrough),);
 
     quote_block! {
         #[allow(non_camel_case_types)]
@@ -1289,7 +1275,7 @@ fn deserialize_custom_identifier(
 
     let names_idents: Vec<_> = ordinary
         .iter()
-        .map(|variant| (variant.attrs.name().deserialize_name(), variant.ident.clone()))
+        .map(|variant| (variant.attrs.name().deserialize_name(), variant.ident.clone()),)
         .collect();
 
     let names = names_idents.iter().map(|&(ref name, _)| name);
@@ -1308,8 +1294,9 @@ fn deserialize_custom_identifier(
         Some(fields)
     };
 
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params);
-    let visitor_impl = Stmts(deserialize_identifier(this.clone(), &names_idents, is_variant, fallthrough));
+    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) = split_with_de_lifetime(params,);
+    let visitor_impl =
+        Stmts(deserialize_identifier(this.clone(), &names_idents, is_variant, fallthrough),);
 
     quote_block! {
         #names_const
@@ -1343,9 +1330,9 @@ fn deserialize_identifier(
     let field_bytes = fields.iter().map(|&(ref name, _)| quote::ByteStr(name));
 
     let constructors: &Vec<_> = &fields
-        .iter()
-        .map(|&(_, ref ident)| quote!(#this::#ident))
-        .collect();
+                                     .iter()
+                                     .map(|&(_, ref ident)| quote!(#this::#ident))
+                                     .collect();
 
     let expecting = if is_variant {
         "variant identifier"

serde_derive/src/ser.rs

@@ -273,11 +273,7 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
     }
 }
 
-fn serialize_enum(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
+fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment {
     assert!(variants.len() as u64 <= u32::MAX as u64);
 
     let self_var = &params.self_var;

serde_derive_internals/src/ast.rs

@@ -87,8 +87,7 @@ impl<'a> Body<'a> {
     pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
         match *self {
             Body::Enum(ref variants) => {
-                Box::new(variants.iter()
-                    .flat_map(|variant| variant.fields.iter()))
+                Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
             }
             Body::Struct(_, ref fields) => Box::new(fields.iter()),
         }
@@ -100,16 +99,19 @@ impl<'a> Body<'a> {
 }
 
 fn enum_from_ast<'a>(cx: &Ctxt, variants: &'a [syn::Variant]) -> Vec<Variant<'a>> {
-    variants.iter()
-        .map(|variant| {
-            let (style, fields) = struct_from_ast(cx, &variant.data);
-            Variant {
-                ident: variant.ident.clone(),
-                attrs: attr::Variant::from_ast(cx, variant),
-                style: style,
-                fields: fields,
-            }
-        })
+    variants
+        .iter()
+        .map(
+            |variant| {
+                let (style, fields) = struct_from_ast(cx, &variant.data);
+                Variant {
+                    ident: variant.ident.clone(),
+                    attrs: attr::Variant::from_ast(cx, variant),
+                    style: style,
+                    fields: fields,
+                }
+            },
+        )
         .collect()
 }
 
@@ -125,14 +127,17 @@ fn struct_from_ast<'a>(cx: &Ctxt, data: &'a syn::VariantData) -> (Style, Vec<Fie
 }
 
 fn fields_from_ast<'a>(cx: &Ctxt, fields: &'a [syn::Field]) -> Vec<Field<'a>> {
-    fields.iter()
+    fields
+        .iter()
         .enumerate()
-        .map(|(i, field)| {
-            Field {
-                ident: field.ident.clone(),
-                attrs: attr::Field::from_ast(cx, i, field),
-                ty: &field.ty,
-            }
-        })
+        .map(
+            |(i, field)| {
+                Field {
+                    ident: field.ident.clone(),
+                    attrs: attr::Field::from_ast(cx, i, field),
+                    ty: &field.ty,
+                }
+            },
+        )
         .collect()
 }