rustdoc: Fix some script-mangled idents

brson · brson · commit bd4365f15b85 · 2012-09-19T15:32:33.000-07:00
diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs
@@ -372,71 +372,71 @@ impl Doc {
 impl ModDoc {
 
     fn mods() -> ~[ModDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               ModTag(ModDoc) => Some(ModDoc),
               _ => None
             }
         }
     }
 
     fn nmods() -> ~[NmodDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               NmodTag(nModDoc) => Some(nModDoc),
               _ => None
             }
         }
     }
 
     fn fns() -> ~[FnDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               FnTag(FnDoc) => Some(FnDoc),
               _ => None
             }
         }
     }
 
     fn consts() -> ~[ConstDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               ConstTag(ConstDoc) => Some(ConstDoc),
               _ => None
             }
         }
     }
 
     fn enums() -> ~[EnumDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               EnumTag(EnumDoc) => Some(EnumDoc),
               _ => None
             }
         }
     }
 
     fn traits() -> ~[TraitDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               TraitTag(TraitDoc) => Some(TraitDoc),
               _ => None
             }
         }
     }
 
     fn impls() -> ~[ImplDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               ImplTag(ImplDoc) => Some(ImplDoc),
               _ => None
             }
         }
     }
 
     fn types() -> ~[TyDoc] {
-        do vec::filter_map(self.items) |ItemTag| {
-            match ItemTag {
+        do vec::filter_map(self.items) |itemtag| {
+            match itemtag {
               TyTag(TyDoc) => Some(TyDoc),
               _ => None
             }
diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs
@@ -44,21 +44,21 @@ fn extract(
     doc::Doc_({
         pages: ~[
             doc::CratePage({
-                topmod: top_ModDoc_from_crate(crate, default_name),
+                topmod: top_moddoc_from_crate(crate, default_name),
             })
         ]
     })
 }
 
-fn top_ModDoc_from_crate(
+fn top_moddoc_from_crate(
     crate: @ast::crate,
     default_name: ~str
 ) -> doc::ModDoc {
-    ModDoc_from_mod(mk_ItemDoc(ast::crate_node_id, default_name),
+    moddoc_from_mod(mk_itemdoc(ast::crate_node_id, default_name),
                     crate.node.module)
 }
 
-fn mk_ItemDoc(id: ast::node_id, name: ~str) -> doc::ItemDoc {
+fn mk_itemdoc(id: ast::node_id, name: ~str) -> doc::ItemDoc {
     {
         id: id,
         name: name,
@@ -70,53 +70,53 @@ fn mk_ItemDoc(id: ast::node_id, name: ~str) -> doc::ItemDoc {
     }
 }
 
-fn ModDoc_from_mod(
-    ItemDoc: doc::ItemDoc,
+fn moddoc_from_mod(
+    itemdoc: doc::ItemDoc,
     module_: ast::_mod
 ) -> doc::ModDoc {
     doc::ModDoc_({
-        item: ItemDoc,
+        item: itemdoc,
         items: do vec::filter_map(module_.items) |item| {
-            let ItemDoc = mk_ItemDoc(item.id, to_str(item.ident));
+            let ItemDoc = mk_itemdoc(item.id, to_str(item.ident));
             match item.node {
               ast::item_mod(m) => {
                 Some(doc::ModTag(
-                    ModDoc_from_mod(ItemDoc, m)
+                    moddoc_from_mod(ItemDoc, m)
                 ))
               }
               ast::item_foreign_mod(nm) => {
                 Some(doc::NmodTag(
-                    nModDoc_from_mod(ItemDoc, nm)
+                    nmoddoc_from_mod(ItemDoc, nm)
                 ))
               }
               ast::item_fn(*) => {
                 Some(doc::FnTag(
-                    FnDoc_from_fn(ItemDoc)
+                    fndoc_from_fn(ItemDoc)
                 ))
               }
               ast::item_const(_, _) => {
                 Some(doc::ConstTag(
-                    ConstDoc_from_const(ItemDoc)
+                    constdoc_from_const(ItemDoc)
                 ))
               }
               ast::item_enum(enum_definition, _) => {
                 Some(doc::EnumTag(
-                    EnumDoc_from_enum(ItemDoc, enum_definition.variants)
+                    enumdoc_from_enum(ItemDoc, enum_definition.variants)
                 ))
               }
               ast::item_trait(_, _, methods) => {
                 Some(doc::TraitTag(
-                    TraitDoc_from_trait(ItemDoc, methods)
+                    traitdoc_from_trait(ItemDoc, methods)
                 ))
               }
               ast::item_impl(_, _, _, methods) => {
                 Some(doc::ImplTag(
-                    ImplDoc_from_impl(ItemDoc, methods)
+                    impldoc_from_impl(ItemDoc, methods)
                 ))
               }
               ast::item_ty(_, _) => {
                 Some(doc::TyTag(
-                    TyDoc_from_ty(ItemDoc)
+                    tydoc_from_ty(ItemDoc)
                 ))
               }
               _ => None
@@ -126,37 +126,37 @@ fn ModDoc_from_mod(
     })
 }
 
-fn nModDoc_from_mod(
-    ItemDoc: doc::ItemDoc,
+fn nmoddoc_from_mod(
+    itemdoc: doc::ItemDoc,
     module_: ast::foreign_mod
 ) -> doc::NmodDoc {
     let mut fns = ~[];
     for module_.items.each |item| {
-        let ItemDoc = mk_ItemDoc(item.id, to_str(item.ident));
+        let ItemDoc = mk_itemdoc(item.id, to_str(item.ident));
         match item.node {
           ast::foreign_item_fn(*) => {
-            vec::push(fns, FnDoc_from_fn(ItemDoc));
+            vec::push(fns, fndoc_from_fn(ItemDoc));
           }
           ast::foreign_item_const(*) => {} // XXX: Not implemented.
         }
     }
     {
-        item: ItemDoc,
+        item: itemdoc,
         fns: fns,
         index: None
     }
 }
 
-fn FnDoc_from_fn(ItemDoc: doc::ItemDoc) -> doc::FnDoc {
+fn fndoc_from_fn(itemdoc: doc::ItemDoc) -> doc::FnDoc {
     {
-        item: ItemDoc,
+        item: itemdoc,
         sig: None
     }
 }
 
-fn ConstDoc_from_const(ItemDoc: doc::ItemDoc) -> doc::ConstDoc {
+fn constdoc_from_const(itemdoc: doc::ItemDoc) -> doc::ConstDoc {
     {
-        item: ItemDoc,
+        item: itemdoc,
         sig: None
     }
 }
@@ -168,12 +168,12 @@ fn should_extract_const_name_and_id() {
     assert doc.cratemod().consts()[0].name() == ~"a";
 }
 
-fn EnumDoc_from_enum(
-    ItemDoc: doc::ItemDoc,
+fn enumdoc_from_enum(
+    itemdoc: doc::ItemDoc,
     variants: ~[ast::variant]
 ) -> doc::EnumDoc {
     {
-        item: ItemDoc,
+        item: itemdoc,
         variants: variantdocs_from_variants(variants)
     }
 }
@@ -206,12 +206,12 @@ fn should_extract_enum_variants() {
     assert doc.cratemod().enums()[0].variants[0].name == ~"v";
 }
 
-fn TraitDoc_from_trait(
-    ItemDoc: doc::ItemDoc,
+fn traitdoc_from_trait(
+    itemdoc: doc::ItemDoc,
     methods: ~[ast::trait_method]
 ) -> doc::TraitDoc {
     {
-        item: ItemDoc,
+        item: itemdoc,
         methods: do vec::map(methods) |method| {
             match method {
               ast::required(ty_m) => {
@@ -251,12 +251,12 @@ fn should_extract_trait_methods() {
     assert doc.cratemod().traits()[0].methods[0].name == ~"f";
 }
 
-fn ImplDoc_from_impl(
-    ItemDoc: doc::ItemDoc,
+fn impldoc_from_impl(
+    itemdoc: doc::ItemDoc,
     methods: ~[@ast::method]
 ) -> doc::ImplDoc {
     {
-        item: ItemDoc,
+        item: itemdoc,
         trait_types: ~[],
         self_ty: None,
         methods: do vec::map(methods) |method| {
@@ -278,11 +278,11 @@ fn should_extract_impl_methods() {
     assert doc.cratemod().impls()[0].methods[0].name == ~"f";
 }
 
-fn TyDoc_from_ty(
-    ItemDoc: doc::ItemDoc
+fn tydoc_from_ty(
+    itemdoc: doc::ItemDoc
 ) -> doc::TyDoc {
     {
-        item: ItemDoc,
+        item: itemdoc,
         sig: None
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -372,71 +372,71 @@ impl Doc {`
`372`	`372`	`impl ModDoc {`
`373`	`373`
`374`	`374`	`fn mods() -> ~[ModDoc] {`
`375`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`376`		`- match ItemTag {`
	`375`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`376`	`+ match itemtag {`
`377`	`377`	`ModTag(ModDoc) => Some(ModDoc),`
`378`	`378`	`_ => None`
`379`	`379`	`}`
`380`	`380`	`}`
`381`	`381`	`}`
`382`	`382`
`383`	`383`	`fn nmods() -> ~[NmodDoc] {`
`384`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`385`		`- match ItemTag {`
	`384`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`385`	`+ match itemtag {`
`386`	`386`	`NmodTag(nModDoc) => Some(nModDoc),`
`387`	`387`	`_ => None`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`	`}`
`391`	`391`
`392`	`392`	`fn fns() -> ~[FnDoc] {`
`393`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`394`		`- match ItemTag {`
	`393`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`394`	`+ match itemtag {`
`395`	`395`	`FnTag(FnDoc) => Some(FnDoc),`
`396`	`396`	`_ => None`
`397`	`397`	`}`
`398`	`398`	`}`
`399`	`399`	`}`
`400`	`400`
`401`	`401`	`fn consts() -> ~[ConstDoc] {`
`402`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`403`		`- match ItemTag {`
	`402`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`403`	`+ match itemtag {`
`404`	`404`	`ConstTag(ConstDoc) => Some(ConstDoc),`
`405`	`405`	`_ => None`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`	`}`
`409`	`409`
`410`	`410`	`fn enums() -> ~[EnumDoc] {`
`411`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`412`		`- match ItemTag {`
	`411`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`412`	`+ match itemtag {`
`413`	`413`	`EnumTag(EnumDoc) => Some(EnumDoc),`
`414`	`414`	`_ => None`
`415`	`415`	`}`
`416`	`416`	`}`
`417`	`417`	`}`
`418`	`418`
`419`	`419`	`fn traits() -> ~[TraitDoc] {`
`420`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`421`		`- match ItemTag {`
	`420`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`421`	`+ match itemtag {`
`422`	`422`	`TraitTag(TraitDoc) => Some(TraitDoc),`
`423`	`423`	`_ => None`
`424`	`424`	`}`
`425`	`425`	`}`
`426`	`426`	`}`
`427`	`427`
`428`	`428`	`fn impls() -> ~[ImplDoc] {`
`429`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`430`		`- match ItemTag {`
	`429`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`430`	`+ match itemtag {`
`431`	`431`	`ImplTag(ImplDoc) => Some(ImplDoc),`
`432`	`432`	`_ => None`
`433`	`433`	`}`
`434`	`434`	`}`
`435`	`435`	`}`
`436`	`436`
`437`	`437`	`fn types() -> ~[TyDoc] {`
`438`		`- do vec::filter_map(self.items) \|ItemTag\| {`
`439`		`- match ItemTag {`
	`438`	`+ do vec::filter_map(self.items) \|itemtag\| {`
	`439`	`+ match itemtag {`
`440`	`440`	`TyTag(TyDoc) => Some(TyDoc),`
`441`	`441`	`_ => None`
`442`	`442`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,21 +44,21 @@ fn extract(`
`44`	`44`	`doc::Doc_({`
`45`	`45`	`pages: ~[`
`46`	`46`	`doc::CratePage({`
`47`		`- topmod: top_ModDoc_from_crate(crate, default_name),`
	`47`	`+ topmod: top_moddoc_from_crate(crate, default_name),`
`48`	`48`	`})`
`49`	`49`	`]`
`50`	`50`	`})`
`51`	`51`	`}`
`52`	`52`
`53`		`-fn top_ModDoc_from_crate(`
	`53`	`+fn top_moddoc_from_crate(`
`54`	`54`	`crate: @ast::crate,`
`55`	`55`	`default_name: ~str`
`56`	`56`	`) -> doc::ModDoc {`
`57`		`- ModDoc_from_mod(mk_ItemDoc(ast::crate_node_id, default_name),`
	`57`	`+ moddoc_from_mod(mk_itemdoc(ast::crate_node_id, default_name),`
`58`	`58`	`crate.node.module)`
`59`	`59`	`}`
`60`	`60`
`61`		`-fn mk_ItemDoc(id: ast::node_id, name: ~str) -> doc::ItemDoc {`
	`61`	`+fn mk_itemdoc(id: ast::node_id, name: ~str) -> doc::ItemDoc {`
`62`	`62`	`{`
`63`	`63`	`id: id,`
`64`	`64`	`name: name,`
`@@ -70,53 +70,53 @@ fn mk_ItemDoc(id: ast::node_id, name: ~str) -> doc::ItemDoc {`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`73`		`-fn ModDoc_from_mod(`
`74`		`- ItemDoc: doc::ItemDoc,`
	`73`	`+fn moddoc_from_mod(`
	`74`	`+ itemdoc: doc::ItemDoc,`
`75`	`75`	`module_: ast::_mod`
`76`	`76`	`) -> doc::ModDoc {`
`77`	`77`	`doc::ModDoc_({`
`78`		`- item: ItemDoc,`
	`78`	`+ item: itemdoc,`
`79`	`79`	`items: do vec::filter_map(module_.items) \|item\| {`
`80`		`- let ItemDoc = mk_ItemDoc(item.id, to_str(item.ident));`
	`80`	`+ let ItemDoc = mk_itemdoc(item.id, to_str(item.ident));`
`81`	`81`	`match item.node {`
`82`	`82`	`ast::item_mod(m) => {`
`83`	`83`	`Some(doc::ModTag(`
`84`		`- ModDoc_from_mod(ItemDoc, m)`
	`84`	`+ moddoc_from_mod(ItemDoc, m)`
`85`	`85`	`))`
`86`	`86`	`}`
`87`	`87`	`ast::item_foreign_mod(nm) => {`
`88`	`88`	`Some(doc::NmodTag(`
`89`		`- nModDoc_from_mod(ItemDoc, nm)`
	`89`	`+ nmoddoc_from_mod(ItemDoc, nm)`
`90`	`90`	`))`
`91`	`91`	`}`
`92`	`92`	`ast::item_fn(*) => {`
`93`	`93`	`Some(doc::FnTag(`
`94`		`- FnDoc_from_fn(ItemDoc)`
	`94`	`+ fndoc_from_fn(ItemDoc)`
`95`	`95`	`))`
`96`	`96`	`}`
`97`	`97`	`ast::item_const(_, _) => {`
`98`	`98`	`Some(doc::ConstTag(`
`99`		`- ConstDoc_from_const(ItemDoc)`
	`99`	`+ constdoc_from_const(ItemDoc)`
`100`	`100`	`))`
`101`	`101`	`}`
`102`	`102`	`ast::item_enum(enum_definition, _) => {`
`103`	`103`	`Some(doc::EnumTag(`
`104`		`- EnumDoc_from_enum(ItemDoc, enum_definition.variants)`
	`104`	`+ enumdoc_from_enum(ItemDoc, enum_definition.variants)`
`105`	`105`	`))`
`106`	`106`	`}`
`107`	`107`	`ast::item_trait(_, _, methods) => {`
`108`	`108`	`Some(doc::TraitTag(`
`109`		`- TraitDoc_from_trait(ItemDoc, methods)`
	`109`	`+ traitdoc_from_trait(ItemDoc, methods)`
`110`	`110`	`))`
`111`	`111`	`}`
`112`	`112`	`ast::item_impl(_, _, _, methods) => {`
`113`	`113`	`Some(doc::ImplTag(`
`114`		`- ImplDoc_from_impl(ItemDoc, methods)`
	`114`	`+ impldoc_from_impl(ItemDoc, methods)`
`115`	`115`	`))`
`116`	`116`	`}`
`117`	`117`	`ast::item_ty(_, _) => {`
`118`	`118`	`Some(doc::TyTag(`
`119`		`- TyDoc_from_ty(ItemDoc)`
	`119`	`+ tydoc_from_ty(ItemDoc)`
`120`	`120`	`))`
`121`	`121`	`}`
`122`	`122`	`_ => None`
`@@ -126,37 +126,37 @@ fn ModDoc_from_mod(`
`126`	`126`	`})`
`127`	`127`	`}`
`128`	`128`
`129`		`-fn nModDoc_from_mod(`
`130`		`- ItemDoc: doc::ItemDoc,`
	`129`	`+fn nmoddoc_from_mod(`
	`130`	`+ itemdoc: doc::ItemDoc,`
`131`	`131`	`module_: ast::foreign_mod`
`132`	`132`	`) -> doc::NmodDoc {`
`133`	`133`	`let mut fns = ~[];`
`134`	`134`	`for module_.items.each \|item\| {`
`135`		`- let ItemDoc = mk_ItemDoc(item.id, to_str(item.ident));`
	`135`	`+ let ItemDoc = mk_itemdoc(item.id, to_str(item.ident));`
`136`	`136`	`match item.node {`
`137`	`137`	`ast::foreign_item_fn(*) => {`
`138`		`- vec::push(fns, FnDoc_from_fn(ItemDoc));`
	`138`	`+ vec::push(fns, fndoc_from_fn(ItemDoc));`
`139`	`139`	`}`
`140`	`140`	`ast::foreign_item_const(*) => {} // XXX: Not implemented.`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`	`{`
`144`		`- item: ItemDoc,`
	`144`	`+ item: itemdoc,`
`145`	`145`	`fns: fns,`
`146`	`146`	`index: None`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`150`		`-fn FnDoc_from_fn(ItemDoc: doc::ItemDoc) -> doc::FnDoc {`
	`150`	`+fn fndoc_from_fn(itemdoc: doc::ItemDoc) -> doc::FnDoc {`
`151`	`151`	`{`
`152`		`- item: ItemDoc,`
	`152`	`+ item: itemdoc,`
`153`	`153`	`sig: None`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`157`		`-fn ConstDoc_from_const(ItemDoc: doc::ItemDoc) -> doc::ConstDoc {`
	`157`	`+fn constdoc_from_const(itemdoc: doc::ItemDoc) -> doc::ConstDoc {`
`158`	`158`	`{`
`159`		`- item: ItemDoc,`
	`159`	`+ item: itemdoc,`
`160`	`160`	`sig: None`
`161`	`161`	`}`
`162`	`162`	`}`
`@@ -168,12 +168,12 @@ fn should_extract_const_name_and_id() {`
`168`	`168`	`assert doc.cratemod().consts()[0].name() == ~"a";`
`169`	`169`	`}`
`170`	`170`
`171`		`-fn EnumDoc_from_enum(`
`172`		`- ItemDoc: doc::ItemDoc,`
	`171`	`+fn enumdoc_from_enum(`
	`172`	`+ itemdoc: doc::ItemDoc,`
`173`	`173`	`variants: ~[ast::variant]`
`174`	`174`	`) -> doc::EnumDoc {`
`175`	`175`	`{`
`176`		`- item: ItemDoc,`
	`176`	`+ item: itemdoc,`
`177`	`177`	`variants: variantdocs_from_variants(variants)`
`178`	`178`	`}`
`179`	`179`	`}`
`@@ -206,12 +206,12 @@ fn should_extract_enum_variants() {`
`206`	`206`	`assert doc.cratemod().enums()[0].variants[0].name == ~"v";`
`207`	`207`	`}`
`208`	`208`
`209`		`-fn TraitDoc_from_trait(`
`210`		`- ItemDoc: doc::ItemDoc,`
	`209`	`+fn traitdoc_from_trait(`
	`210`	`+ itemdoc: doc::ItemDoc,`
`211`	`211`	`methods: ~[ast::trait_method]`
`212`	`212`	`) -> doc::TraitDoc {`
`213`	`213`	`{`
`214`		`- item: ItemDoc,`
	`214`	`+ item: itemdoc,`
`215`	`215`	`methods: do vec::map(methods) \|method\| {`
`216`	`216`	`match method {`
`217`	`217`	`ast::required(ty_m) => {`
`@@ -251,12 +251,12 @@ fn should_extract_trait_methods() {`
`251`	`251`	`assert doc.cratemod().traits()[0].methods[0].name == ~"f";`
`252`	`252`	`}`
`253`	`253`
`254`		`-fn ImplDoc_from_impl(`
`255`		`- ItemDoc: doc::ItemDoc,`
	`254`	`+fn impldoc_from_impl(`
	`255`	`+ itemdoc: doc::ItemDoc,`
`256`	`256`	`methods: ~[@ast::method]`
`257`	`257`	`) -> doc::ImplDoc {`
`258`	`258`	`{`
`259`		`- item: ItemDoc,`
	`259`	`+ item: itemdoc,`
`260`	`260`	`trait_types: ~[],`
`261`	`261`	`self_ty: None,`
`262`	`262`	`methods: do vec::map(methods) \|method\| {`
`@@ -278,11 +278,11 @@ fn should_extract_impl_methods() {`
`278`	`278`	`assert doc.cratemod().impls()[0].methods[0].name == ~"f";`
`279`	`279`	`}`
`280`	`280`
`281`		`-fn TyDoc_from_ty(`
`282`		`- ItemDoc: doc::ItemDoc`
	`281`	`+fn tydoc_from_ty(`
	`282`	`+ itemdoc: doc::ItemDoc`
`283`	`283`	`) -> doc::TyDoc {`
`284`	`284`	`{`
`285`		`- item: ItemDoc,`
	`285`	`+ item: itemdoc,`
`286`	`286`	`sig: None`
`287`	`287`	`}`
`288`	`288`	`}`