update

[rust.git] / src / librustdoc / fold.rs

diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
index cfa22bc27b7587ed99b94bd1b119240b6ccd385a..0a85cb1d5a69ff3b2ba54b816d89d912795273cd 100644 (file)
--- 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(),
         }
     }
 
@@ -105,12 +93,15 @@ fn fold_crate(&mut self, mut c: Crate) -> Crate {
         c.module = c.module.take().and_then(|module| self.fold_item(module));
 
         {
-            let guard = c.external_traits.lock();
-            let traits = guard.replace(Default::default());
-            guard.borrow_mut().extend(traits.into_iter().map(|(k, mut v)| {
-                v.items = v.items.into_iter().filter_map(|i| self.fold_item(i)).collect();
-                (k, v)
-            }));
+            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();
         }
         c
     }