rustdoc: Various bits of modernization

Author: brson

src/librustdoc/astsrv.rs

@@ -22,6 +22,7 @@ use core::prelude::*;
 use parse;
 use util;
 
+use core::pipes::stream;
 use core::oldcomm;
 use core::vec;
 use rustc::back::link;
@@ -62,18 +63,18 @@ impl Srv: Clone {
 }
 
 pub fn from_str<T>(source: ~str, owner: SrvOwner<T>) -> T {
-    run(owner, source, parse::from_str_sess)
+    run(owner, copy source, parse::from_str_sess)
 }
 
 pub fn from_file<T>(file: ~str, owner: SrvOwner<T>) -> T {
-    run(owner, file, |sess, f| parse::from_file_sess(sess, &Path(f)))
+    run(owner, copy file, |sess, f| parse::from_file_sess(sess, &Path(f)))
 }
 
 fn run<T>(owner: SrvOwner<T>, source: ~str, +parse: Parser) -> T {
 
     let srv_ = Srv({
-        ch: do util::spawn_listener |move parse, po| {
-            act(po, source, parse);
+        ch: do util::spawn_listener |copy source, move parse, po| {
+            act(po, copy source, parse);
         }
     });
 
@@ -87,7 +88,7 @@ fn act(po: oldcomm::Port<Msg>, source: ~str, parse: Parser) {
 
     let ctxt = build_ctxt(
         sess,
-        parse(sess, source)
+        parse(sess, copy source)
     );
 
     let mut keep_going = true;
@@ -107,13 +108,12 @@ pub fn exec<T:Owned>(
     srv: Srv,
     +f: fn~(ctxt: Ctxt) -> T
 ) -> T {
-    let po = oldcomm::Port();
-    let ch = oldcomm::Chan(&po);
+    let (po, ch) = stream();
     let msg = HandleRequest(fn~(move f, ctxt: Ctxt) {
-        oldcomm::send(ch, f(ctxt))
+        ch.send(f(ctxt))
     });
     oldcomm::send(srv.ch, move msg);
-    oldcomm::recv(po)
+    po.recv()
 }
 
 fn build_ctxt(sess: Session,
@@ -123,7 +123,7 @@ fn build_ctxt(sess: Session,
 
     let ast = config::strip_unconfigured_items(ast);
     let ast = syntax::ext::expand::expand_crate(sess.parse_sess,
-                                                sess.opts.cfg, ast);
+                                                copy sess.opts.cfg, ast);
     let ast = front::test::modify_for_testing(sess, ast);
     let ast_map = ast_map::map_crate(sess.diagnostic(), *ast);
 

src/librustdoc/attr_pass.rs

@@ -65,17 +65,18 @@ fn fold_crate(
     let doc = fold::default_seq_fold_crate(fold, doc);
 
     let attrs = do astsrv::exec(srv) |ctxt| {
-        let attrs = ctxt.ast.node.attrs;
+        let attrs = copy ctxt.ast.node.attrs;
         attr_parser::parse_crate(attrs)
     };
 
     doc::CrateDoc {
         topmod: doc::ModDoc {
             item: doc::ItemDoc {
-                name: option::get_or_default(attrs.name, doc.topmod.name()),
-                .. doc.topmod.item
+                name: option::get_or_default(copy attrs.name,
+                                             doc.topmod.name()),
+                .. copy doc.topmod.item
             },
-            .. doc.topmod
+            .. copy doc.topmod
         }
     }
 }
@@ -97,7 +98,7 @@ fn fold_item(
     let desc = if doc.id == ast::crate_node_id {
         // This is the top-level mod, use the crate attributes
         do astsrv::exec(srv) |ctxt| {
-            attr_parser::parse_desc(ctxt.ast.node.attrs)
+            attr_parser::parse_desc(copy ctxt.ast.node.attrs)
         }
     } else {
         parse_item_attrs(srv, doc.id, attr_parser::parse_desc)
@@ -115,8 +116,8 @@ fn parse_item_attrs<T:Owned>(
     +parse_attrs: fn~(+a: ~[ast::attribute]) -> T) -> T {
     do astsrv::exec(srv) |move parse_attrs, ctxt| {
         let attrs = match ctxt.ast_map.get(id) {
-          ast_map::node_item(item, _) => item.attrs,
-          ast_map::node_foreign_item(item, _, _) => item.attrs,
+          ast_map::node_item(item, _) => copy item.attrs,
+          ast_map::node_foreign_item(item, _, _) => copy item.attrs,
           _ => fail ~"parse_item_attrs: not an item"
         };
         parse_attrs(attrs)
@@ -164,18 +165,18 @@ fn fold_enum(
 
     doc::EnumDoc {
         variants: do par::map(doc.variants) |variant| {
-            let variant = *variant;
-            let desc = do astsrv::exec(srv) |ctxt| {
+            let variant = copy *variant;
+            let desc = do astsrv::exec(srv) |ctxt, copy variant| {
                 match ctxt.ast_map.get(doc_id) {
                   ast_map::node_item(@ast::item {
-                    node: ast::item_enum(enum_definition, _), _
+                    node: ast::item_enum(ref enum_definition, _), _
                   }, _) => {
                     let ast_variant = option::get(
                         vec::find(enum_definition.variants, |v| {
                             to_str(v.node.name) == variant.name
                         }));
 
-                    attr_parser::parse_desc(ast_variant.node.attrs)
+                    attr_parser::parse_desc(copy ast_variant.node.attrs)
                   }
                   _ => fail fmt!("Enum variant %s has id that's not bound \
                          to an enum item", variant.name)
@@ -212,7 +213,7 @@ fn fold_trait(
     let doc = fold::default_seq_fold_trait(fold, doc);
 
     doc::TraitDoc {
-        methods: merge_method_attrs(srv, doc.id(), doc.methods),
+        methods: merge_method_attrs(srv, doc.id(), copy doc.methods),
         .. doc
     }
 }
@@ -227,25 +228,26 @@ fn merge_method_attrs(
     let attrs: ~[(~str, Option<~str>)] = do astsrv::exec(srv) |ctxt| {
         match ctxt.ast_map.get(item_id) {
           ast_map::node_item(@ast::item {
-            node: ast::item_trait(_, _, methods), _
+            node: ast::item_trait(_, _, ref methods), _
           }, _) => {
-            vec::map(methods, |method| {
-                match *method {
+            vec::map(*methods, |method| {
+                match copy *method {
                   ast::required(ty_m) => {
-                    (to_str(ty_m.ident), attr_parser::parse_desc(ty_m.attrs))
+                    (to_str(ty_m.ident),
+                     attr_parser::parse_desc(copy ty_m.attrs))
                   }
                   ast::provided(m) => {
-                    (to_str(m.ident), attr_parser::parse_desc(m.attrs))
+                    (to_str(m.ident), attr_parser::parse_desc(copy m.attrs))
                   }
                 }
             })
           }
           ast_map::node_item(@ast::item {
-            node: ast::item_impl(_, _, _, methods), _
+            node: ast::item_impl(_, _, _, ref methods), _
           }, _) => {
-            vec::map(methods, |method| {
+            vec::map(*methods, |method| {
                 (to_str(method.ident),
-                 attr_parser::parse_desc(method.attrs))
+                 attr_parser::parse_desc(copy method.attrs))
             })
           }
           _ => fail ~"unexpected item"
@@ -258,7 +260,7 @@ fn merge_method_attrs(
 
         doc::MethodDoc {
             desc: desc,
-            ..*doc
+            .. copy *doc
         }
     }
 }
@@ -288,7 +290,7 @@ fn fold_impl(
     let doc = fold::default_seq_fold_impl(fold, doc);
 
     doc::ImplDoc {
-        methods: merge_method_attrs(srv, doc.id(), doc.methods),
+        methods: merge_method_attrs(srv, doc.id(), copy doc.methods),
         .. doc
     }
 }
@@ -318,7 +320,7 @@ mod test {
     use extract;
 
     pub fn mk_doc(source: ~str) -> doc::Doc {
-        do astsrv::from_str(source) |srv| {
+        do astsrv::from_str(copy source) |srv| {
             let doc = extract::from_srv(srv, ~"");
             run(srv, doc)
         }

src/librustdoc/config.rs

@@ -96,7 +96,7 @@ pub fn usage() {
 
 pub fn default_config(input_crate: &Path) -> Config {
     Config {
-        input_crate: *input_crate,
+        input_crate: copy *input_crate,
         output_dir: Path("."),
         output_format: PandocHtml,
         output_style: DocPerMod,
@@ -156,35 +156,35 @@ fn config_from_opts(
         let output_dir = getopts::opt_maybe_str(matches, opt_output_dir());
         let output_dir = output_dir.map(|s| Path(*s));
         result::Ok(Config {
-            output_dir: output_dir.get_or_default(config.output_dir),
+            output_dir: output_dir.get_or_default(copy config.output_dir),
             .. config
         })
     };
     let result = do result::chain(result) |config| {
         let output_format = getopts::opt_maybe_str(
             matches, opt_output_format());
-        do output_format.map_default(result::Ok(config))
+        do output_format.map_default(result::Ok(copy config))
             |output_format| {
             do result::chain(parse_output_format(*output_format))
                 |output_format| {
 
                 result::Ok(Config {
                     output_format: output_format,
-                    .. config
+                    .. copy config
                 })
             }
         }
     };
     let result = do result::chain(result) |config| {
         let output_style =
             getopts::opt_maybe_str(matches, opt_output_style());
-        do output_style.map_default(result::Ok(config))
+        do output_style.map_default(result::Ok(copy config))
             |output_style| {
             do result::chain(parse_output_style(*output_style))
                 |output_style| {
                 result::Ok(Config {
                     output_style: output_style,
-                    .. config
+                    .. copy config
                 })
             }
         }
@@ -197,7 +197,7 @@ fn config_from_opts(
         do result::chain(pandoc_cmd) |pandoc_cmd| {
             result::Ok(Config {
                 pandoc_cmd: pandoc_cmd,
-                .. config
+                .. copy config
             })
         }
     };

src/librustdoc/desc_to_brief_pass.rs

@@ -63,7 +63,7 @@ fn fold_trait(fold: &fold::Fold<()>, +doc: doc::TraitDoc) -> doc::TraitDoc {
     doc::TraitDoc {
         methods: par::map(doc.methods, |doc| doc::MethodDoc {
             brief: extract(doc.desc),
-            .. *doc
+            .. copy *doc
         }),
         .. doc
     }
@@ -75,7 +75,7 @@ fn fold_impl(fold: &fold::Fold<()>, +doc: doc::ImplDoc) -> doc::ImplDoc {
     doc::ImplDoc {
         methods: par::map(doc.methods, |doc| doc::MethodDoc {
             brief: extract(doc.desc),
-            .. *doc
+            .. copy *doc
         }),
         .. doc
     }
@@ -109,7 +109,7 @@ pub mod test {
     use extract;
 
     pub fn mk_doc(source: ~str) -> doc::Doc {
-        do astsrv::from_str(source) |srv| {
+        do astsrv::from_str(copy source) |srv| {
             let doc = extract::from_srv(srv, ~"");
             let doc = (attr_pass::mk_pass().f)(srv, doc);
             run(srv, doc)
@@ -122,14 +122,14 @@ fn extract(desc: Option<~str>) -> Option<~str> {
         return None
     }
 
-    parse_desc(desc.get())
+    parse_desc((copy desc).get())
 }
 
 fn parse_desc(desc: ~str) -> Option<~str> {
 
     const max_brief_len: uint = 120u;
 
-    match first_sentence(desc) {
+    match first_sentence(copy desc) {
       Some(first_sentence) => {
         if str::len(first_sentence) <= max_brief_len {
             Some(first_sentence)
@@ -142,7 +142,7 @@ fn parse_desc(desc: ~str) -> Option<~str> {
 }
 
 fn first_sentence(s: ~str) -> Option<~str> {
-    let paras = paragraphs(s);
+    let paras = paragraphs(copy s);
     if !paras.is_empty() {
         let first_para = vec::head(paras);
         Some(str::replace(first_sentence_(first_para), ~"\n", ~" "))
@@ -176,7 +176,7 @@ fn first_sentence_(s: ~str) -> ~str {
         if str::ends_with(s, ~".") {
             str::slice(s, 0u, str::len(s))
         } else {
-            s
+            copy s
         }
       }
     }
@@ -202,7 +202,7 @@ fn paragraphs(s: ~str) -> ~[~str] {
             whitespace_lines = 0;
 
             accum = if str::is_empty(accum) {
-                *line
+                copy *line
             } else {
                 accum + ~"\n" + *line
             }