2012-11-19 20:00:12 -06:00
|
|
|
pub enum Fold<T> = Fold_<T>;
|
2012-01-16 16:49:40 -06:00
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
impl<T: Clone> Fold<T>: Clone {
|
|
|
|
fn clone(&self) -> Fold<T> {
|
|
|
|
Fold({
|
|
|
|
ctxt: self.ctxt.clone(),
|
|
|
|
fold_doc: copy self.fold_doc,
|
|
|
|
fold_crate: copy self.fold_crate,
|
|
|
|
fold_item: copy self.fold_item,
|
|
|
|
fold_mod: copy self.fold_mod,
|
|
|
|
fold_nmod: copy self.fold_nmod,
|
|
|
|
fold_fn: copy self.fold_fn,
|
|
|
|
fold_const: copy self.fold_const,
|
|
|
|
fold_enum: copy self.fold_enum,
|
|
|
|
fold_trait: copy self.fold_trait,
|
|
|
|
fold_impl: copy self.fold_impl,
|
|
|
|
fold_type: copy self.fold_type,
|
|
|
|
fold_struct: copy self.fold_struct
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-19 20:48:46 -06:00
|
|
|
type FoldDoc<T> = fn~(fold: &Fold<T>, +doc: doc::Doc) -> doc::Doc;
|
|
|
|
type FoldCrate<T> = fn~(fold: &Fold<T>, +doc: doc::CrateDoc) -> doc::CrateDoc;
|
|
|
|
type FoldItem<T> = fn~(fold: &Fold<T>, +doc: doc::ItemDoc) -> doc::ItemDoc;
|
|
|
|
type FoldMod<T> = fn~(fold: &Fold<T>, +doc: doc::ModDoc) -> doc::ModDoc;
|
|
|
|
type FoldNmod<T> = fn~(fold: &Fold<T>, +doc: doc::NmodDoc) -> doc::NmodDoc;
|
|
|
|
type FoldFn<T> = fn~(fold: &Fold<T>, +doc: doc::FnDoc) -> doc::FnDoc;
|
|
|
|
type FoldConst<T> = fn~(fold: &Fold<T>, +doc: doc::ConstDoc) -> doc::ConstDoc;
|
|
|
|
type FoldEnum<T> = fn~(fold: &Fold<T>, +doc: doc::EnumDoc) -> doc::EnumDoc;
|
|
|
|
type FoldTrait<T> = fn~(fold: &Fold<T>, +doc: doc::TraitDoc) -> doc::TraitDoc;
|
|
|
|
type FoldImpl<T> = fn~(fold: &Fold<T>, +doc: doc::ImplDoc) -> doc::ImplDoc;
|
|
|
|
type FoldType<T> = fn~(fold: &Fold<T>, +doc: doc::TyDoc) -> doc::TyDoc;
|
|
|
|
type FoldStruct<T> = fn~(fold: &Fold<T>,
|
|
|
|
+doc: doc::StructDoc) -> doc::StructDoc;
|
2012-01-16 16:49:40 -06:00
|
|
|
|
2012-09-18 18:48:40 -05:00
|
|
|
type Fold_<T> = {
|
2012-01-16 17:31:49 -06:00
|
|
|
ctxt: T,
|
2012-09-18 18:48:40 -05:00
|
|
|
fold_doc: FoldDoc<T>,
|
|
|
|
fold_crate: FoldCrate<T>,
|
|
|
|
fold_item: FoldItem<T>,
|
|
|
|
fold_mod: FoldMod<T>,
|
|
|
|
fold_nmod: FoldNmod<T>,
|
|
|
|
fold_fn: FoldFn<T>,
|
|
|
|
fold_const: FoldConst<T>,
|
|
|
|
fold_enum: FoldEnum<T>,
|
|
|
|
fold_trait: FoldTrait<T>,
|
|
|
|
fold_impl: FoldImpl<T>,
|
2012-09-19 16:37:43 -05:00
|
|
|
fold_type: FoldType<T>,
|
|
|
|
fold_struct: FoldStruct<T>
|
2012-01-16 16:49:40 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// This exists because fn types don't infer correctly as record
|
|
|
|
// initializers, but they do as function arguments
|
2012-11-26 20:03:36 -06:00
|
|
|
fn mk_fold<T:Clone>(
|
2012-11-21 00:36:32 -06:00
|
|
|
+ctxt: T,
|
2012-09-18 18:48:40 -05:00
|
|
|
+fold_doc: FoldDoc<T>,
|
|
|
|
+fold_crate: FoldCrate<T>,
|
|
|
|
+fold_item: FoldItem<T>,
|
|
|
|
+fold_mod: FoldMod<T>,
|
|
|
|
+fold_nmod: FoldNmod<T>,
|
|
|
|
+fold_fn: FoldFn<T>,
|
|
|
|
+fold_const: FoldConst<T>,
|
|
|
|
+fold_enum: FoldEnum<T>,
|
|
|
|
+fold_trait: FoldTrait<T>,
|
|
|
|
+fold_impl: FoldImpl<T>,
|
2012-09-19 16:37:43 -05:00
|
|
|
+fold_type: FoldType<T>,
|
|
|
|
+fold_struct: FoldStruct<T>
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> Fold<T> {
|
|
|
|
Fold({
|
2012-11-26 20:03:36 -06:00
|
|
|
ctxt: move ctxt,
|
2012-09-19 00:43:54 -05:00
|
|
|
fold_doc: move fold_doc,
|
|
|
|
fold_crate: move fold_crate,
|
|
|
|
fold_item: move fold_item,
|
|
|
|
fold_mod: move fold_mod,
|
|
|
|
fold_nmod: move fold_nmod,
|
|
|
|
fold_fn: move fold_fn,
|
|
|
|
fold_const: move fold_const,
|
|
|
|
fold_enum: move fold_enum,
|
|
|
|
fold_trait: move fold_trait,
|
|
|
|
fold_impl: move fold_impl,
|
|
|
|
fold_type: move fold_type,
|
|
|
|
fold_struct: move fold_struct
|
2012-01-16 16:49:40 -06:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
pub fn default_any_fold<T:Send Clone>(+ctxt: T) -> Fold<T> {
|
2012-02-27 00:38:35 -06:00
|
|
|
mk_fold(
|
2012-11-26 20:03:36 -06:00
|
|
|
move ctxt,
|
2012-06-30 18:19:07 -05:00
|
|
|
|f, d| default_seq_fold_doc(f, d),
|
|
|
|
|f, d| default_seq_fold_crate(f, d),
|
|
|
|
|f, d| default_seq_fold_item(f, d),
|
|
|
|
|f, d| default_any_fold_mod(f, d),
|
|
|
|
|f, d| default_any_fold_nmod(f, d),
|
|
|
|
|f, d| default_seq_fold_fn(f, d),
|
|
|
|
|f, d| default_seq_fold_const(f, d),
|
|
|
|
|f, d| default_seq_fold_enum(f, d),
|
2012-07-03 18:30:42 -05:00
|
|
|
|f, d| default_seq_fold_trait(f, d),
|
2012-06-30 18:19:07 -05:00
|
|
|
|f, d| default_seq_fold_impl(f, d),
|
2012-09-19 16:37:43 -05:00
|
|
|
|f, d| default_seq_fold_type(f, d),
|
|
|
|
|f, d| default_seq_fold_struct(f, d)
|
2012-02-27 00:38:35 -06:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
pub fn default_seq_fold<T:Clone>(+ctxt: T) -> Fold<T> {
|
2012-01-16 16:49:40 -06:00
|
|
|
mk_fold(
|
2012-11-26 20:03:36 -06:00
|
|
|
move ctxt,
|
2012-06-30 18:19:07 -05:00
|
|
|
|f, d| default_seq_fold_doc(f, d),
|
|
|
|
|f, d| default_seq_fold_crate(f, d),
|
|
|
|
|f, d| default_seq_fold_item(f, d),
|
|
|
|
|f, d| default_seq_fold_mod(f, d),
|
|
|
|
|f, d| default_seq_fold_nmod(f, d),
|
|
|
|
|f, d| default_seq_fold_fn(f, d),
|
|
|
|
|f, d| default_seq_fold_const(f, d),
|
|
|
|
|f, d| default_seq_fold_enum(f, d),
|
2012-07-03 18:30:42 -05:00
|
|
|
|f, d| default_seq_fold_trait(f, d),
|
2012-06-30 18:19:07 -05:00
|
|
|
|f, d| default_seq_fold_impl(f, d),
|
2012-09-19 16:37:43 -05:00
|
|
|
|f, d| default_seq_fold_type(f, d),
|
|
|
|
|f, d| default_seq_fold_struct(f, d)
|
2012-01-16 16:49:40 -06:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
pub fn default_par_fold<T:Send Clone>(+ctxt: T) -> Fold<T> {
|
2012-02-21 00:08:24 -06:00
|
|
|
mk_fold(
|
2012-11-26 20:03:36 -06:00
|
|
|
move ctxt,
|
2012-06-30 18:19:07 -05:00
|
|
|
|f, d| default_seq_fold_doc(f, d),
|
|
|
|
|f, d| default_seq_fold_crate(f, d),
|
|
|
|
|f, d| default_seq_fold_item(f, d),
|
|
|
|
|f, d| default_par_fold_mod(f, d),
|
|
|
|
|f, d| default_par_fold_nmod(f, d),
|
|
|
|
|f, d| default_seq_fold_fn(f, d),
|
|
|
|
|f, d| default_seq_fold_const(f, d),
|
|
|
|
|f, d| default_seq_fold_enum(f, d),
|
2012-07-03 18:30:42 -05:00
|
|
|
|f, d| default_seq_fold_trait(f, d),
|
2012-06-30 18:19:07 -05:00
|
|
|
|f, d| default_seq_fold_impl(f, d),
|
2012-09-19 16:37:43 -05:00
|
|
|
|f, d| default_seq_fold_type(f, d),
|
|
|
|
|f, d| default_seq_fold_struct(f, d)
|
2012-02-21 00:08:24 -06:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2012-11-19 20:48:46 -06:00
|
|
|
pub fn default_seq_fold_doc<T>(fold: &Fold<T>, +doc: doc::Doc) -> doc::Doc {
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::Doc_({
|
2012-07-13 12:36:35 -05:00
|
|
|
pages: do vec::map(doc.pages) |page| {
|
2012-09-21 20:43:30 -05:00
|
|
|
match *page {
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::CratePage(doc) => {
|
|
|
|
doc::CratePage(fold.fold_crate(fold, doc))
|
2012-03-02 20:33:25 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::ItemPage(doc) => {
|
|
|
|
doc::ItemPage(fold_ItemTag(fold, doc))
|
2012-03-02 20:33:25 -06:00
|
|
|
}
|
|
|
|
}
|
2012-09-04 15:29:32 -05:00
|
|
|
},
|
|
|
|
.. *doc
|
2012-07-11 17:00:40 -05:00
|
|
|
})
|
2012-03-02 20:33:25 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_crate<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::CrateDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::CrateDoc {
|
2012-01-30 15:05:25 -06:00
|
|
|
{
|
2012-01-16 16:49:40 -06:00
|
|
|
topmod: fold.fold_mod(fold, doc.topmod)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_item<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
_fold: &Fold<T>,
|
|
|
|
+doc: doc::ItemDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::ItemDoc {
|
2012-02-17 17:51:58 -06:00
|
|
|
doc
|
|
|
|
}
|
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
pub fn default_any_fold_mod<T:Send Clone>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::ModDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::ModDoc {
|
2012-11-26 20:03:36 -06:00
|
|
|
let fold_copy = fold.clone();
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::ModDoc_({
|
2012-02-17 17:51:58 -06:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
2012-11-19 20:48:46 -06:00
|
|
|
items: par::map(doc.items, |ItemTag, move fold_copy| {
|
|
|
|
fold_ItemTag(&fold_copy, *ItemTag)
|
2012-09-04 15:29:32 -05:00
|
|
|
}),
|
|
|
|
.. *doc
|
2012-07-11 17:00:40 -05:00
|
|
|
})
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_mod<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::ModDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::ModDoc {
|
|
|
|
doc::ModDoc_({
|
2012-02-24 15:34:35 -06:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
2012-09-18 18:48:40 -05:00
|
|
|
items: vec::map(doc.items, |ItemTag| {
|
2012-09-21 20:43:30 -05:00
|
|
|
fold_ItemTag(fold, *ItemTag)
|
2012-09-04 15:29:32 -05:00
|
|
|
}),
|
|
|
|
.. *doc
|
2012-07-11 17:00:40 -05:00
|
|
|
})
|
2012-02-24 15:34:35 -06:00
|
|
|
}
|
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
pub fn default_par_fold_mod<T:Send Clone>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::ModDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::ModDoc {
|
2012-11-26 20:03:36 -06:00
|
|
|
let fold_copy = fold.clone();
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::ModDoc_({
|
2012-02-21 00:08:24 -06:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
2012-11-19 20:48:46 -06:00
|
|
|
items: par::map(doc.items, |ItemTag, move fold_copy| {
|
|
|
|
fold_ItemTag(&fold_copy, *ItemTag)
|
2012-09-04 15:29:32 -05:00
|
|
|
}),
|
|
|
|
.. *doc
|
2012-07-11 17:00:40 -05:00
|
|
|
})
|
2012-01-16 16:49:40 -06:00
|
|
|
}
|
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
pub fn default_any_fold_nmod<T:Send Clone>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::NmodDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::NmodDoc {
|
2012-11-26 20:03:36 -06:00
|
|
|
let fold_copy = fold.clone();
|
2012-02-27 00:58:24 -06:00
|
|
|
{
|
|
|
|
item: fold.fold_item(fold, doc.item),
|
2012-11-19 20:48:46 -06:00
|
|
|
fns: par::map(doc.fns, |FnDoc, move fold_copy| {
|
|
|
|
fold_copy.fold_fn(&fold_copy, *FnDoc)
|
2012-09-04 15:29:32 -05:00
|
|
|
}),
|
|
|
|
.. doc
|
2012-02-27 00:58:24 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_nmod<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::NmodDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::NmodDoc {
|
2012-02-27 00:38:35 -06:00
|
|
|
{
|
|
|
|
item: fold.fold_item(fold, doc.item),
|
2012-09-18 18:48:40 -05:00
|
|
|
fns: vec::map(doc.fns, |FnDoc| {
|
2012-09-21 20:43:30 -05:00
|
|
|
fold.fold_fn(fold, *FnDoc)
|
2012-09-04 15:29:32 -05:00
|
|
|
}),
|
|
|
|
.. doc
|
2012-02-27 00:58:24 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-26 20:03:36 -06:00
|
|
|
pub fn default_par_fold_nmod<T:Send Clone>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::NmodDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::NmodDoc {
|
2012-11-26 20:03:36 -06:00
|
|
|
let fold_copy = fold.clone();
|
2012-02-27 00:58:24 -06:00
|
|
|
{
|
|
|
|
item: fold.fold_item(fold, doc.item),
|
2012-11-19 20:48:46 -06:00
|
|
|
fns: par::map(doc.fns, |FnDoc, move fold_copy| {
|
|
|
|
fold_copy.fold_fn(&fold_copy, *FnDoc)
|
2012-09-04 15:29:32 -05:00
|
|
|
}),
|
|
|
|
.. doc
|
2012-02-27 00:38:35 -06:00
|
|
|
}
|
2012-02-21 00:24:59 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:48:46 -06:00
|
|
|
pub fn fold_ItemTag<T>(fold: &Fold<T>, +doc: doc::ItemTag) -> doc::ItemTag {
|
2012-08-06 14:34:08 -05:00
|
|
|
match doc {
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::ModTag(ModDoc) => {
|
|
|
|
doc::ModTag(fold.fold_mod(fold, ModDoc))
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::NmodTag(nModDoc) => {
|
|
|
|
doc::NmodTag(fold.fold_nmod(fold, nModDoc))
|
2012-02-24 15:34:35 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::FnTag(FnDoc) => {
|
|
|
|
doc::FnTag(fold.fold_fn(fold, FnDoc))
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::ConstTag(ConstDoc) => {
|
|
|
|
doc::ConstTag(fold.fold_const(fold, ConstDoc))
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::EnumTag(EnumDoc) => {
|
|
|
|
doc::EnumTag(fold.fold_enum(fold, EnumDoc))
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::TraitTag(TraitDoc) => {
|
|
|
|
doc::TraitTag(fold.fold_trait(fold, TraitDoc))
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::ImplTag(ImplDoc) => {
|
|
|
|
doc::ImplTag(fold.fold_impl(fold, ImplDoc))
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
2012-09-18 18:48:40 -05:00
|
|
|
doc::TyTag(TyDoc) => {
|
|
|
|
doc::TyTag(fold.fold_type(fold, TyDoc))
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
2012-09-19 16:37:43 -05:00
|
|
|
doc::StructTag(StructDoc) => {
|
|
|
|
doc::StructTag(fold.fold_struct(fold, StructDoc))
|
|
|
|
}
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_fn<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::FnDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::FnDoc {
|
2012-02-17 17:51:58 -06:00
|
|
|
{
|
2012-09-04 15:29:32 -05:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
|
|
|
.. doc
|
2012-02-17 17:51:58 -06:00
|
|
|
}
|
2012-01-16 16:49:40 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_const<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::ConstDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::ConstDoc {
|
2012-02-17 17:51:58 -06:00
|
|
|
{
|
2012-09-04 15:29:32 -05:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
|
|
|
.. doc
|
2012-02-17 17:51:58 -06:00
|
|
|
}
|
2012-01-24 01:40:30 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_enum<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::EnumDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::EnumDoc {
|
2012-02-17 17:51:58 -06:00
|
|
|
{
|
2012-09-04 15:29:32 -05:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
|
|
|
.. doc
|
2012-02-17 17:51:58 -06:00
|
|
|
}
|
2012-01-25 18:56:28 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_trait<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::TraitDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::TraitDoc {
|
2012-02-17 17:51:58 -06:00
|
|
|
{
|
2012-09-04 15:29:32 -05:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
|
|
|
.. doc
|
2012-02-17 17:51:58 -06:00
|
|
|
}
|
2012-01-30 16:11:35 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_impl<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::ImplDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::ImplDoc {
|
2012-02-17 17:51:58 -06:00
|
|
|
{
|
2012-09-04 15:29:32 -05:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
|
|
|
.. doc
|
2012-02-17 17:51:58 -06:00
|
|
|
}
|
2012-01-31 17:28:09 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_type<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::TyDoc
|
2012-09-18 18:48:40 -05:00
|
|
|
) -> doc::TyDoc {
|
2012-02-17 17:51:58 -06:00
|
|
|
{
|
2012-09-04 15:29:32 -05:00
|
|
|
item: fold.fold_item(fold, doc.item),
|
|
|
|
.. doc
|
2012-02-17 17:51:58 -06:00
|
|
|
}
|
2012-02-02 00:41:41 -06:00
|
|
|
}
|
|
|
|
|
2012-11-19 20:00:12 -06:00
|
|
|
pub fn default_seq_fold_struct<T>(
|
2012-11-19 20:48:46 -06:00
|
|
|
fold: &Fold<T>,
|
|
|
|
+doc: doc::StructDoc
|
2012-09-19 16:37:43 -05:00
|
|
|
) -> doc::StructDoc {
|
|
|
|
{
|
|
|
|
item: fold.fold_item(fold, doc.item),
|
|
|
|
.. doc
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-24 01:40:30 -06:00
|
|
|
#[test]
|
|
|
|
fn default_fold_should_produce_same_doc() {
|
2012-07-14 00:57:48 -05:00
|
|
|
let source = ~"mod a { fn b() { } mod c { fn d() { } } }";
|
2012-04-30 13:52:07 -05:00
|
|
|
let ast = parse::from_str(source);
|
2012-07-14 00:57:48 -05:00
|
|
|
let doc = extract::extract(ast, ~"");
|
2012-01-24 01:40:30 -06:00
|
|
|
let fld = default_seq_fold(());
|
2012-11-19 20:48:46 -06:00
|
|
|
let folded = fld.fold_doc(&fld, doc);
|
2012-01-24 01:40:30 -06:00
|
|
|
assert doc == folded;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn default_fold_should_produce_same_consts() {
|
2012-07-14 00:57:48 -05:00
|
|
|
let source = ~"const a: int = 0;";
|
2012-04-30 13:52:07 -05:00
|
|
|
let ast = parse::from_str(source);
|
2012-07-14 00:57:48 -05:00
|
|
|
let doc = extract::extract(ast, ~"");
|
2012-01-24 01:40:30 -06:00
|
|
|
let fld = default_seq_fold(());
|
2012-11-19 20:48:46 -06:00
|
|
|
let folded = fld.fold_doc(&fld, doc);
|
2012-01-24 01:40:30 -06:00
|
|
|
assert doc == folded;
|
2012-01-25 18:56:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn default_fold_should_produce_same_enums() {
|
2012-07-14 00:57:48 -05:00
|
|
|
let source = ~"enum a { b }";
|
2012-04-30 13:52:07 -05:00
|
|
|
let ast = parse::from_str(source);
|
2012-07-14 00:57:48 -05:00
|
|
|
let doc = extract::extract(ast, ~"");
|
2012-01-25 18:56:28 -06:00
|
|
|
let fld = default_seq_fold(());
|
2012-11-19 20:48:46 -06:00
|
|
|
let folded = fld.fold_doc(&fld, doc);
|
2012-01-25 18:56:28 -06:00
|
|
|
assert doc == folded;
|
2012-02-21 00:08:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn default_parallel_fold_should_produce_same_doc() {
|
2012-07-14 00:57:48 -05:00
|
|
|
let source = ~"mod a { fn b() { } mod c { fn d() { } } }";
|
2012-04-30 13:52:07 -05:00
|
|
|
let ast = parse::from_str(source);
|
2012-07-14 00:57:48 -05:00
|
|
|
let doc = extract::extract(ast, ~"");
|
2012-02-21 00:08:24 -06:00
|
|
|
let fld = default_par_fold(());
|
2012-11-19 20:48:46 -06:00
|
|
|
let folded = fld.fold_doc(&fld, doc);
|
2012-02-21 00:08:24 -06:00
|
|
|
assert doc == folded;
|
|
|
|
}
|