X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Flibrustdoc%2Ffold.rs;h=0a85cb1d5a69ff3b2ba54b816d89d912795273cd;hb=9a78c2b11d50fc1ed60c92eec7cb59ae74516e89;hp=5482239c7ce28dd2b1ac3da5be0ba57f341b82f8;hpb=4134241bcf79a77c724158cc388a746499c5fa06;p=rust.git

diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
index 5482239c7ce..0a85cb1d5a6 100644
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -14,7 +14,7 @@ pub fn strip(self) -> Option<Item> {
     }
 }
 
-pub trait DocFolder : Sized {
+pub trait DocFolder: Sized {
     fn fold_item(&mut self, item: Item) -> Option<Item> {
         self.fold_item_recur(item)
     }
@@ -23,81 +23,69 @@ fn fold_item(&mut self, item: Item) -> Option<Item> {
     fn fold_inner_recur(&mut self, inner: ItemEnum) -> ItemEnum {
         match inner {
             StrippedItem(..) => unreachable!(),
-            ModuleItem(i) => {
-                ModuleItem(self.fold_mod(i))
-            },
+            ModuleItem(i) => ModuleItem(self.fold_mod(i)),
             StructItem(mut i) => {
                 let num_fields = i.fields.len();
                 i.fields = i.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
-                i.fields_stripped |= num_fields != i.fields.len() ||
-                                     i.fields.iter().any(|f| f.is_stripped());
+                i.fields_stripped |=
+                    num_fields != i.fields.len() || i.fields.iter().any(|f| f.is_stripped());
                 StructItem(i)
-            },
+            }
             UnionItem(mut i) => {
                 let num_fields = i.fields.len();
                 i.fields = i.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
-                i.fields_stripped |= num_fields != i.fields.len() ||
-                                     i.fields.iter().any(|f| f.is_stripped());
+                i.fields_stripped |=
+                    num_fields != i.fields.len() || i.fields.iter().any(|f| f.is_stripped());
                 UnionItem(i)
-            },
+            }
             EnumItem(mut i) => {
                 let num_variants = i.variants.len();
                 i.variants = i.variants.into_iter().filter_map(|x| self.fold_item(x)).collect();
-                i.variants_stripped |= num_variants != i.variants.len() ||
-                                       i.variants.iter().any(|f| f.is_stripped());
+                i.variants_stripped |=
+                    num_variants != i.variants.len() || i.variants.iter().any(|f| f.is_stripped());
                 EnumItem(i)
-            },
+            }
             TraitItem(mut i) => {
                 i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect();
                 TraitItem(i)
-            },
+            }
             ImplItem(mut i) => {
                 i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect();
                 ImplItem(i)
-            },
+            }
             VariantItem(i) => {
                 let i2 = i.clone(); // this clone is small
                 match i.kind {
                     VariantKind::Struct(mut j) => {
                         let num_fields = j.fields.len();
                         j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
-                        j.fields_stripped |= num_fields != j.fields.len() ||
-                                             j.fields.iter().any(|f| f.is_stripped());
-                        VariantItem(Variant {kind: VariantKind::Struct(j), ..i2})
-                    },
-                    _ => VariantItem(i2)
+                        j.fields_stripped |= num_fields != j.fields.len()
+                            || j.fields.iter().any(|f| f.is_stripped());
+                        VariantItem(Variant { kind: VariantKind::Struct(j), ..i2 })
+                    }
+                    _ => VariantItem(i2),
                 }
-            },
-            x => x
+            }
+            x => x,
         }
     }
 
     /// don't override!
     fn fold_item_recur(&mut self, item: Item) -> Option<Item> {
-        let Item {
-            attrs,
-            name,
-            source,
-            visibility,
-            def_id,
-            inner,
-            stability,
-            deprecation,
-        } = item;
+        let Item { attrs, name, source, visibility, def_id, inner, stability, deprecation } = item;
 
         let inner = match inner {
             StrippedItem(box i) => StrippedItem(box self.fold_inner_recur(i)),
             _ => self.fold_inner_recur(inner),
         };
 
-        Some(Item { attrs, name, source, inner, visibility,
-                    stability, deprecation, def_id })
+        Some(Item { attrs, name, source, inner, visibility, stability, deprecation, def_id })
     }
 
     fn fold_mod(&mut self, m: Module) -> Module {
         Module {
             is_crate: m.is_crate,
-            items: m.items.into_iter().filter_map(|i| self.fold_item(i)).collect()
+            items: m.items.into_iter().filter_map(|i| self.fold_item(i)).collect(),
         }
     }
 
@@ -107,10 +95,13 @@ fn fold_crate(&mut self, mut c: Crate) -> Crate {
         {
             let mut guard = c.external_traits.borrow_mut();
             let external_traits = std::mem::replace(&mut *guard, Default::default());
-            *guard = external_traits.into_iter().map(|(k, mut v)| {
-                v.items = v.items.into_iter().filter_map(|i| self.fold_item(i)).collect();
-                (k, v)
-            }).collect();
+            *guard = external_traits
+                .into_iter()
+                .map(|(k, mut v)| {
+                    v.items = v.items.into_iter().filter_map(|i| self.fold_item(i)).collect();
+                    (k, v)
+                })
+                .collect();
         }
         c
     }