---

yaml
---
r: 28580
b: refs/heads/try
c: b3b1e62
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: e86e8c16e6b10d2b58577d10e713149f7f8a97fa
+refs/heads/try: b3b1e62750bbce86833409ac59d9797fd5ba2964
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/src/rustdoc/astsrv.rs

@@ -21,53 +21,53 @@ use rustc::back::link;
 use rustc::metadata::filesearch;
 use rustc::front;
 
-export ctxt;
-export ctxt_handler;
-export srv;
+export Ctxt;
+export CtxtHandler;
+export Srv;
 export from_str;
 export from_file;
 export exec;
 
-type ctxt = {
+type Ctxt = {
     ast: @ast::crate,
     ast_map: ast_map::map
 };
 
-type srv_owner<T> = fn(srv: srv) -> T;
-type ctxt_handler<T> = fn~(ctxt: ctxt) -> T;
-type parser = fn~(session, ~str) -> @ast::crate;
+type SrvOwner<T> = fn(srv: Srv) -> T;
+type CtxtHandler<T> = fn~(ctxt: Ctxt) -> T;
+type Parser = fn~(session, ~str) -> @ast::crate;
 
-enum msg {
-    handle_request(fn~(ctxt)),
-    exit
+enum Msg {
+    HandleRequest(fn~(Ctxt)),
+    Exit
 }
 
-enum srv = {
-    ch: comm::Chan<msg>
+enum Srv = {
+    ch: comm::Chan<Msg>
 };
 
-fn from_str<T>(source: ~str, owner: srv_owner<T>) -> T {
+fn from_str<T>(source: ~str, owner: SrvOwner<T>) -> T {
     run(owner, source, parse::from_str_sess)
 }
 
-fn from_file<T>(file: ~str, owner: srv_owner<T>) -> T {
+fn from_file<T>(file: ~str, owner: SrvOwner<T>) -> T {
     run(owner, file, |sess, f| parse::from_file_sess(sess, &Path(f)))
 }
 
-fn run<T>(owner: srv_owner<T>, source: ~str, +parse: parser) -> T {
+fn run<T>(owner: SrvOwner<T>, source: ~str, +parse: Parser) -> T {
 
-    let srv_ = srv({
+    let srv_ = Srv({
         ch: do task::spawn_listener |po| {
             act(po, source, parse);
         }
     });
 
     let res = owner(srv_);
-    comm::send(srv_.ch, exit);
+    comm::send(srv_.ch, Exit);
     return res;
 }
 
-fn act(po: comm::Port<msg>, source: ~str, parse: parser) {
+fn act(po: comm::Port<Msg>, source: ~str, parse: Parser) {
     let sess = build_session();
 
     let ctxt = build_ctxt(
@@ -78,31 +78,31 @@ fn act(po: comm::Port<msg>, source: ~str, parse: parser) {
     let mut keep_going = true;
     while keep_going {
         match comm::recv(po) {
-          handle_request(f) => {
+          HandleRequest(f) => {
             f(ctxt);
           }
-          exit => {
+          Exit => {
             keep_going = false;
           }
         }
     }
 }
 
 fn exec<T:Send>(
-    srv: srv,
-    +f: fn~(ctxt: ctxt) -> T
+    srv: Srv,
+    +f: fn~(ctxt: Ctxt) -> T
 ) -> T {
     let po = comm::Port();
     let ch = comm::Chan(po);
-    let msg = handle_request(fn~(move f, ctxt: ctxt) {
+    let msg = HandleRequest(fn~(move f, ctxt: Ctxt) {
         comm::send(ch, f(ctxt))
     });
     comm::send(srv.ch, msg);
     comm::recv(po)
 }
 
 fn build_ctxt(sess: session,
-              ast: @ast::crate) -> ctxt {
+              ast: @ast::crate) -> Ctxt {
 
     use rustc::front::config;
 
@@ -129,7 +129,7 @@ fn build_session() -> session {
     session
 }
 
-type error_handlers = {
+type ErrorHandlers = {
     emitter: diagnostic::emitter,
     span_handler: diagnostic::span_handler
 };
@@ -138,13 +138,13 @@ type error_handlers = {
 // errors
 fn build_error_handlers(
     codemap: codemap::codemap
-) -> error_handlers {
+) -> ErrorHandlers {
 
-    type diagnostic_handler = {
+    type DiagnosticHandler = {
         inner: diagnostic::handler,
     };
 
-    impl diagnostic_handler: diagnostic::handler {
+    impl DiagnosticHandler: diagnostic::handler {
         fn fatal(msg: ~str) -> ! { self.inner.fatal(msg) }
         fn err(msg: ~str) { self.inner.err(msg) }
         fn bump_err_count() {

branches/try/src/rustdoc/attr_parser.rs

@@ -9,11 +9,11 @@ use syntax::ast;
 use syntax::attr;
 use core::tuple;
 
-export crate_attrs;
+export CrateAttrs;
 export parse_crate, parse_desc;
 export parse_hidden;
 
-type crate_attrs = {
+type CrateAttrs = {
     name: Option<~str>
 };
 
@@ -59,7 +59,7 @@ fn doc_meta(
     }
 }
 
-fn parse_crate(attrs: ~[ast::attribute]) -> crate_attrs {
+fn parse_crate(attrs: ~[ast::attribute]) -> CrateAttrs {
     let link_metas = attr::find_linkage_metas(attrs);
 
     {

branches/try/src/rustdoc/attr_pass.rs

@@ -6,26 +6,26 @@
      of the natural-language documentation for a crate."
 )];
 
-use doc::item_utils;
+use doc::ItemUtils;
 use extract::to_str;
 use syntax::ast;
 use syntax::ast_map;
 use std::map::HashMap;
 
 export mk_pass;
 
-fn mk_pass() -> pass {
+fn mk_pass() -> Pass {
     {
         name: ~"attr",
         f: run
     }
 }
 
 fn run(
-    srv: astsrv::srv,
-    doc: doc::doc
-) -> doc::doc {
-    let fold = fold::fold({
+    srv: astsrv::Srv,
+    doc: doc::Doc
+) -> doc::Doc {
+    let fold = fold::Fold({
         fold_crate: fold_crate,
         fold_item: fold_item,
         fold_enum: fold_enum,
@@ -37,9 +37,9 @@ fn run(
 }
 
 fn fold_crate(
-    fold: fold::fold<astsrv::srv>,
-    doc: doc::cratedoc
-) -> doc::cratedoc {
+    fold: fold::Fold<astsrv::Srv>,
+    doc: doc::CrateDoc
+) -> doc::CrateDoc {
 
     let srv = fold.ctxt;
     let doc = fold::default_seq_fold_crate(fold, doc);
@@ -50,7 +50,7 @@ fn fold_crate(
     };
 
     {
-        topmod: doc::moddoc_({
+        topmod: doc::ModDoc_({
             item: {
                 name: option::get_default(attrs.name, doc.topmod.name()),
                 .. doc.topmod.item
@@ -67,9 +67,9 @@ fn should_replace_top_module_name_with_crate_name() {
 }
 
 fn fold_item(
-    fold: fold::fold<astsrv::srv>,
-    doc: doc::itemdoc
-) -> doc::itemdoc {
+    fold: fold::Fold<astsrv::Srv>,
+    doc: doc::ItemDoc
+) -> doc::ItemDoc {
 
     let srv = fold.ctxt;
     let doc = fold::default_seq_fold_item(fold, doc);
@@ -90,8 +90,8 @@ fn fold_item(
 }
 
 fn parse_item_attrs<T:Send>(
-    srv: astsrv::srv,
-    id: doc::ast_id,
+    srv: astsrv::Srv,
+    id: doc::AstId,
     +parse_attrs: fn~(~[ast::attribute]) -> T) -> T {
     do astsrv::exec(srv) |ctxt| {
         let attrs = match ctxt.ast_map.get(id) {
@@ -134,9 +134,9 @@ fn should_extract_fn_attributes() {
 }
 
 fn fold_enum(
-    fold: fold::fold<astsrv::srv>,
-    doc: doc::enumdoc
-) -> doc::enumdoc {
+    fold: fold::Fold<astsrv::Srv>,
+    doc: doc::EnumDoc
+) -> doc::EnumDoc {
 
     let srv = fold.ctxt;
     let doc_id = doc.id();
@@ -184,9 +184,9 @@ fn should_extract_variant_docs() {
 }
 
 fn fold_trait(
-    fold: fold::fold<astsrv::srv>,
-    doc: doc::traitdoc
-) -> doc::traitdoc {
+    fold: fold::Fold<astsrv::Srv>,
+    doc: doc::TraitDoc
+) -> doc::TraitDoc {
     let srv = fold.ctxt;
     let doc = fold::default_seq_fold_trait(fold, doc);
 
@@ -197,10 +197,10 @@ fn fold_trait(
 }
 
 fn merge_method_attrs(
-    srv: astsrv::srv,
-    item_id: doc::ast_id,
-    docs: ~[doc::methoddoc]
-) -> ~[doc::methoddoc] {
+    srv: astsrv::Srv,
+    item_id: doc::AstId,
+    docs: ~[doc::MethodDoc]
+) -> ~[doc::MethodDoc] {
 
     // Create an assoc list from method name to attributes
     let attrs: ~[(~str, Option<~str>)] = do astsrv::exec(srv) |ctxt| {
@@ -259,9 +259,9 @@ fn should_extract_trait_method_docs() {
 
 
 fn fold_impl(
-    fold: fold::fold<astsrv::srv>,
-    doc: doc::impldoc
-) -> doc::impldoc {
+    fold: fold::Fold<astsrv::Srv>,
+    doc: doc::ImplDoc
+) -> doc::ImplDoc {
     let srv = fold.ctxt;
     let doc = fold::default_seq_fold_impl(fold, doc);
 
@@ -290,7 +290,7 @@ fn should_extract_impl_method_docs() {
 
 #[cfg(test)]
 mod test {
-    fn mk_doc(source: ~str) -> doc::doc {
+    fn mk_doc(source: ~str) -> doc::Doc {
         do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, ~"");
             run(srv, doc)