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.
12 use std
::collections
::HashMap
;
13 use std
::mem
::{replace, swap}
;
15 pub trait DocFolder
: Sized
{
16 fn fold_item(&mut self, item
: Item
) -> Option
<Item
> {
17 self.fold_item_recur(item
)
21 fn fold_item_recur(&mut self, item
: Item
) -> Option
<Item
> {
22 let Item { attrs, name, source, visibility, def_id, inner, stability, deprecation }
= item
;
24 let inner
= match inner
{
25 StructItem(mut i
) => {
26 let mut foo
= Vec
::new(); swap(&mut foo
, &mut i
.fields
);
27 let num_fields
= foo
.len();
28 i
.fields
.extend(foo
.into_iter().filter_map(|x
| self.fold_item(x
)));
29 i
.fields_stripped
|= num_fields
!= i
.fields
.len();
33 ModuleItem(self.fold_mod(i
))
36 let mut foo
= Vec
::new(); swap(&mut foo
, &mut i
.variants
);
37 let num_variants
= foo
.len();
38 i
.variants
.extend(foo
.into_iter().filter_map(|x
| self.fold_item(x
)));
39 i
.variants_stripped
|= num_variants
!= i
.variants
.len();
43 let mut foo
= Vec
::new(); swap(&mut foo
, &mut i
.items
);
44 i
.items
.extend(foo
.into_iter().filter_map(|x
| self.fold_item(x
)));
48 let mut foo
= Vec
::new(); swap(&mut foo
, &mut i
.items
);
49 i
.items
.extend(foo
.into_iter().filter_map(|x
| self.fold_item(x
)));
53 let i2
= i
.clone(); // this clone is small
55 StructVariant(mut j
) => {
56 let mut foo
= Vec
::new(); swap(&mut foo
, &mut j
.fields
);
57 let num_fields
= foo
.len();
58 j
.fields
.extend(foo
.into_iter().filter_map(|x
| self.fold_item(x
)));
59 j
.fields_stripped
|= num_fields
!= j
.fields
.len();
60 VariantItem(Variant {kind: StructVariant(j), ..i2}
)
68 Some(Item
{ attrs
: attrs
, name
: name
, source
: source
, inner
: inner
,
69 visibility
: visibility
, stability
: stability
, deprecation
: deprecation
,
73 fn fold_mod(&mut self, m
: Module
) -> Module
{
76 items
: m
.items
.into_iter().filter_map(|i
| self.fold_item(i
)).collect()
80 fn fold_crate(&mut self, mut c
: Crate
) -> Crate
{
81 c
.module
= match replace(&mut c
.module
, None
) {
82 Some(module
) => self.fold_item(module
), None
=> None
84 let external_traits
= replace(&mut c
.external_traits
, HashMap
::new());
85 c
.external_traits
= external_traits
.into_iter().map(|(k
, mut v
)| {
86 let items
= replace(&mut v
.items
, Vec
::new());
87 v
.items
= items
.into_iter().filter_map(|i
| self.fold_item(i
))