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.
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.
20 pub fn fold(self) -> Option
<Item
> {
22 FoldItem
::Erase
=> None
,
23 FoldItem
::Retain(i
) => Some(i
),
24 FoldItem
::Strip(item@ Item { inner: StrippedItem(..), .. }
) => Some(item
),
25 FoldItem
::Strip(mut i
) => {
26 i
.inner
= StrippedItem(box i
.inner
);
33 pub trait DocFolder
: Sized
{
34 fn fold_item(&mut self, item
: Item
) -> Option
<Item
> {
35 self.fold_item_recur(item
)
39 fn fold_inner_recur(&mut self, inner
: ItemEnum
) -> ItemEnum
{
41 StrippedItem(..) => unreachable
!(),
43 ModuleItem(self.fold_mod(i
))
45 StructItem(mut i
) => {
46 let num_fields
= i
.fields
.len();
47 i
.fields
= i
.fields
.into_iter().filter_map(|x
| self.fold_item(x
)).collect();
48 i
.fields_stripped
|= num_fields
!= i
.fields
.len() ||
49 i
.fields
.iter().any(|f
| f
.is_stripped());
53 let num_variants
= i
.variants
.len();
54 i
.variants
= i
.variants
.into_iter().filter_map(|x
| self.fold_item(x
)).collect();
55 i
.variants_stripped
|= num_variants
!= i
.variants
.len() ||
56 i
.variants
.iter().any(|f
| f
.is_stripped());
60 i
.items
= i
.items
.into_iter().filter_map(|x
| self.fold_item(x
)).collect();
64 i
.items
= i
.items
.into_iter().filter_map(|x
| self.fold_item(x
)).collect();
68 let i2
= i
.clone(); // this clone is small
70 StructVariant(mut j
) => {
71 let num_fields
= j
.fields
.len();
72 j
.fields
= j
.fields
.into_iter().filter_map(|x
| self.fold_item(x
)).collect();
73 j
.fields_stripped
|= num_fields
!= j
.fields
.len() ||
74 j
.fields
.iter().any(|f
| f
.is_stripped());
75 VariantItem(Variant {kind: StructVariant(j), ..i2}
)
85 fn fold_item_recur(&mut self, item
: Item
) -> Option
<Item
> {
86 let Item { attrs, name, source, visibility, def_id, inner, stability, deprecation }
= item
;
88 let inner
= match inner
{
89 StrippedItem(box i
) => StrippedItem(box self.fold_inner_recur(i
)),
90 _
=> self.fold_inner_recur(inner
),
93 Some(Item
{ attrs
: attrs
, name
: name
, source
: source
, inner
: inner
,
94 visibility
: visibility
, stability
: stability
, deprecation
: deprecation
,
98 fn fold_mod(&mut self, m
: Module
) -> Module
{
100 is_crate
: m
.is_crate
,
101 items
: m
.items
.into_iter().filter_map(|i
| self.fold_item(i
)).collect()
105 fn fold_crate(&mut self, mut c
: Crate
) -> Crate
{
106 c
.module
= c
.module
.and_then(|module
| self.fold_item(module
));
108 c
.external_traits
= c
.external_traits
.into_iter().map(|(k
, mut v
)| {
109 v
.items
= v
.items
.into_iter().filter_map(|i
| self.fold_item(i
)).collect();