src/librustdoc/fold.rs

   1 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use clean::*;
  12
  13 pub struct StripItem(pub Item);
  14
  15 impl StripItem {
  16     pub fn strip(self) -> Option<Item> {
  17         match self.0 {
  18             Item { inner: StrippedItem(..), .. } => Some(self.0),
  19             mut i => {
  20                 i.inner = StrippedItem(box i.inner);
  21                 Some(i)
  22             }
  23         }
  24     }
  25 }
  26
  27 pub trait DocFolder : Sized {
  28     fn fold_item(&mut self, item: Item) -> Option<Item> {
  29         self.fold_item_recur(item)
  30     }
  31
  32     /// don't override!
  33     fn fold_inner_recur(&mut self, inner: ItemEnum) -> ItemEnum {
  34         match inner {
  35             StrippedItem(..) => unreachable!(),
  36             ModuleItem(i) => {
  37                 ModuleItem(self.fold_mod(i))
  38             },
  39             StructItem(mut i) => {
  40                 let num_fields = i.fields.len();
  41                 i.fields = i.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
  42                 i.fields_stripped |= num_fields != i.fields.len() ||
  43                                      i.fields.iter().any(|f| f.is_stripped());
  44                 StructItem(i)
  45             },
  46             UnionItem(mut i) => {
  47                 let num_fields = i.fields.len();
  48                 i.fields = i.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
  49                 i.fields_stripped |= num_fields != i.fields.len() ||
  50                                      i.fields.iter().any(|f| f.is_stripped());
  51                 UnionItem(i)
  52             },
  53             EnumItem(mut i) => {
  54                 let num_variants = i.variants.len();
  55                 i.variants = i.variants.into_iter().filter_map(|x| self.fold_item(x)).collect();
  56                 i.variants_stripped |= num_variants != i.variants.len() ||
  57                                        i.variants.iter().any(|f| f.is_stripped());
  58                 EnumItem(i)
  59             },
  60             TraitItem(mut i) => {
  61                 i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect();
  62                 TraitItem(i)
  63             },
  64             ImplItem(mut i) => {
  65                 i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect();
  66                 ImplItem(i)
  67             },
  68             VariantItem(i) => {
  69                 let i2 = i.clone(); // this clone is small
  70                 match i.kind {
  71                     VariantKind::Struct(mut j) => {
  72                         let num_fields = j.fields.len();
  73                         j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
  74                         j.fields_stripped |= num_fields != j.fields.len() ||
  75                                              j.fields.iter().any(|f| f.is_stripped());
  76                         VariantItem(Variant {kind: VariantKind::Struct(j), ..i2})
  77                     },
  78                     _ => VariantItem(i2)
  79                 }
  80             },
  81             x => x
  82         }
  83     }
  84
  85     /// don't override!
  86     fn fold_item_recur(&mut self, item: Item) -> Option<Item> {
  87         let Item {
  88             attrs,
  89             name,
  90             source,
  91             visibility,
  92             def_id,
  93             inner,
  94             stability,
  95             deprecation,
  96         } = item;
  97
  98         let inner = match inner {
  99             StrippedItem(box i) => StrippedItem(box self.fold_inner_recur(i)),
 100             _ => self.fold_inner_recur(inner),
 101         };
 102
 103         Some(Item { attrs, name, source, inner, visibility,
 104                     stability, deprecation, def_id })
 105     }
 106
 107     fn fold_mod(&mut self, m: Module) -> Module {
 108         Module {
 109             is_crate: m.is_crate,
 110             items: m.items.into_iter().filter_map(|i| self.fold_item(i)).collect()
 111         }
 112     }
 113
 114     fn fold_crate(&mut self, mut c: Crate) -> Crate {
 115         c.module = c.module.take().and_then(|module| self.fold_item(module));
 116
 117         {
 118             let guard = c.external_traits.lock();
 119             let traits = guard.replace(Default::default());
 120             guard.borrow_mut().extend(traits.into_iter().map(|(k, mut v)| {
 121                 v.items = v.items.into_iter().filter_map(|i| self.fold_item(i)).collect();
 122                 (k, v)
 123             }));
 124         }
 125         c
 126     }
 127 }