| use crate::clean::*; |
| |
| pub struct StripItem(pub Item); |
| |
| impl StripItem { |
| pub fn strip(self) -> Option<Item> { |
| match self.0 { |
| Item { inner: StrippedItem(..), .. } => Some(self.0), |
| mut i => { |
| i.inner = StrippedItem(box i.inner); |
| Some(i) |
| } |
| } |
| } |
| } |
| |
| pub trait DocFolder: Sized { |
| fn fold_item(&mut self, item: Item) -> Option<Item> { |
| self.fold_item_recur(item) |
| } |
| |
| /// don't override! |
| fn fold_inner_recur(&mut self, inner: ItemEnum) -> ItemEnum { |
| match inner { |
| StrippedItem(..) => unreachable!(), |
| 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()); |
| 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()); |
| 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()); |
| 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), |
| } |
| } |
| 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 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 }) |
| } |
| |
| 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(), |
| } |
| } |
| |
| fn fold_crate(&mut self, mut c: Crate) -> Crate { |
| c.module = c.module.take().and_then(|module| self.fold_item(module)); |
| |
| { |
| 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 |
| } |
| } |