Merge remote-tracking branch 'original/incoming' into incoming

14 files changed, 85 insertions, 90 deletions

diff --git a/src/rustdoc/astsrv.rs b/src/rustdoc/astsrv.rs
index 2e6cbf579c8..7b2c6fe5f0c 100644
--- a/src/rustdoc/astsrv.rs
+++ b/src/rustdoc/astsrv.rs
@@ -10,7 +10,7 @@ non-sendableness.
 use std::map::HashMap;
 use rustc::driver::session;
 use session::{basic_options, options};
-use session::session;
+use session::Session;
 use rustc::driver::driver;
 use syntax::diagnostic;
 use syntax::diagnostic::handler;
@@ -35,7 +35,7 @@ type Ctxt = {
 
 type SrvOwner<T> = fn(srv: Srv) -> T;
 type CtxtHandler<T> = fn~(ctxt: Ctxt) -> T;
-type Parser = fn~(session, ~str) -> @ast::crate;
+type Parser = fn~(Session, ~str) -> @ast::crate;
 
 enum Msg {
     HandleRequest(fn~(Ctxt)),
@@ -57,14 +57,14 @@ fn from_file<T>(file: ~str, owner: SrvOwner<T>) -> T {
 fn run<T>(owner: SrvOwner<T>, source: ~str, +parse: Parser) -> T {
 
     let srv_ = Srv({
-        ch: do task::spawn_listener |po| {
+        ch: do task::spawn_listener |move parse, po| {
             act(po, source, parse);
         }
     });
 
     let res = owner(srv_);
     comm::send(srv_.ch, Exit);
-    return res;
+    move res
 }
 
 fn act(po: comm::Port<Msg>, source: ~str, parse: Parser) {
@@ -97,11 +97,11 @@ fn exec<T:Send>(
     let msg = HandleRequest(fn~(move f, ctxt: Ctxt) {
         comm::send(ch, f(ctxt))
     });
-    comm::send(srv.ch, msg);
+    comm::send(srv.ch, move msg);
     comm::recv(po)
 }
 
-fn build_ctxt(sess: session,
+fn build_ctxt(sess: Session,
               ast: @ast::crate) -> Ctxt {
 
     use rustc::front::config;
@@ -118,7 +118,7 @@ fn build_ctxt(sess: session,
     }
 }
 
-fn build_session() -> session {
+fn build_session() -> Session {
     let sopts: @options = basic_options();
     let codemap = codemap::new_codemap();
     let error_handlers = build_error_handlers(codemap);
@@ -137,7 +137,7 @@ type ErrorHandlers = {
 // Build a custom error handler that will allow us to ignore non-fatal
 // errors
 fn build_error_handlers(
-    codemap: codemap::codemap
+    codemap: codemap::CodeMap
 ) -> ErrorHandlers {
 
     type DiagnosticHandler = {
@@ -156,13 +156,13 @@ fn build_error_handlers(
         fn note(msg: &str) { self.inner.note(msg) }
         fn bug(msg: &str) -> ! { self.inner.bug(msg) }
         fn unimpl(msg: &str) -> ! { self.inner.unimpl(msg) }
-        fn emit(cmsp: Option<(codemap::codemap, codemap::span)>,
+        fn emit(cmsp: Option<(codemap::CodeMap, codemap::span)>,
                 msg: &str, lvl: diagnostic::level) {
             self.inner.emit(cmsp, msg, lvl)
         }
     }
 
-    let emitter = fn@(cmsp: Option<(codemap::codemap, codemap::span)>,
+    let emitter = fn@(cmsp: Option<(codemap::CodeMap, codemap::span)>,
                        msg: &str, lvl: diagnostic::level) {
         diagnostic::emit(cmsp, msg, lvl);
     };
diff --git a/src/rustdoc/attr_parser.rs b/src/rustdoc/attr_parser.rs
index d2b314adf9c..2b16112fe16 100644
--- a/src/rustdoc/attr_parser.rs
+++ b/src/rustdoc/attr_parser.rs
@@ -36,27 +36,6 @@ mod test {
     }
 }
 
-fn doc_meta(
-    attrs: ~[ast::attribute]
-) -> Option<@ast::meta_item> {
-
-    /*!
-     * Given a vec of attributes, extract the meta_items contained in the \
-     * doc attribute
-     */
-
-    let doc_metas = doc_metas(attrs);
-    if vec::is_not_empty(doc_metas) {
-        if vec::len(doc_metas) != 1u {
-            warn!("ignoring %u doc attributes", vec::len(doc_metas) - 1u);
-        }
-        Some(doc_metas[0])
-    } else {
-        None
-    }
-
-}
-
 fn doc_metas(
     attrs: ~[ast::attribute]
 ) -> ~[@ast::meta_item] {
@@ -102,11 +81,13 @@ fn should_not_extract_crate_name_if_no_name_value_in_link_attribute() {
 }
 
 fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> {
-    match doc_meta(attrs) {
-      Some(meta) => {
-        attr::get_meta_item_value_str(meta)
-      }
-      None => None
+    let doc_strs = do doc_metas(attrs).filter_map |meta| {
+        attr::get_meta_item_value_str(*meta)
+    };
+    if doc_strs.is_empty() {
+        None
+    } else {
+        Some(str::connect(doc_strs, "\n"))
     }
 }
 
@@ -158,3 +139,12 @@ fn should_not_parse_non_hidden_attribute() {
     let attrs = test::parse_attributes(source);
     assert parse_hidden(attrs) == false;
 }
+
+#[test]
+fn should_concatenate_multiple_doc_comments() {
+    let source = ~"/// foo\n/// bar";
+    let desc = parse_desc(test::parse_attributes(source));
+    assert desc == Some(~"foo\nbar");
+}
+
+
diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs
index d5f0ca9f507..0748f603580 100644
--- a/src/rustdoc/attr_pass.rs
+++ b/src/rustdoc/attr_pass.rs
@@ -52,7 +52,7 @@ fn fold_crate(
     {
         topmod: doc::ModDoc_({
             item: {
-                name: option::get_default(&attrs.name, doc.topmod.name()),
+                name: option::get_default(attrs.name, doc.topmod.name()),
                 .. doc.topmod.item
             },
             .. *doc.topmod
@@ -93,7 +93,7 @@ fn parse_item_attrs<T:Send>(
     srv: astsrv::Srv,
     id: doc::AstId,
     +parse_attrs: fn~(~[ast::attribute]) -> T) -> T {
-    do astsrv::exec(srv) |ctxt| {
+    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,
@@ -151,13 +151,13 @@ fn fold_enum(
                     node: ast::item_enum(enum_definition, _), _
                   }, _) => {
                     let ast_variant = option::get(
-                        &vec::find(enum_definition.variants, |v| {
+                        vec::find(enum_definition.variants, |v| {
                             to_str(v.node.name) == variant.name
                         }));
 
                     attr_parser::parse_desc(ast_variant.node.attrs)
                   }
-                  _ => fail #fmt("Enum variant %s has id that's not bound \
+                  _ => fail fmt!("Enum variant %s has id that's not bound \
                          to an enum item", variant.name)
                 }
             };
diff --git a/src/rustdoc/demo.rs b/src/rustdoc/demo.rs
index bf1cdf2622e..1223f6b9723 100644
--- a/src/rustdoc/demo.rs
+++ b/src/rustdoc/demo.rs
@@ -7,7 +7,7 @@
  * for testing purposes. It doesn't surve any functional
  * purpose. This here, for instance, is just some filler text.
  *
- * FIXME (#1654): It would be nice if we could run some automated
+ * FIXME (#3731): It would be nice if we could run some automated
  * tests on this file
  */
 
diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs
index 0764d9e2432..2d5bf5fc3c6 100644
--- a/src/rustdoc/doc.rs
+++ b/src/rustdoc/doc.rs
@@ -377,7 +377,7 @@ impl IndexEntry : cmp::Eq {
 
 impl Doc {
     fn CrateDoc() -> CrateDoc {
-        option::get(&vec::foldl(None, self.pages, |_m, page| {
+        option::get(vec::foldl(None, self.pages, |_m, page| {
             match *page {
               doc::CratePage(doc) => Some(doc),
               _ => None
diff --git a/src/rustdoc/fold.rs b/src/rustdoc/fold.rs
index 28dbdaeea80..e8d914bd2cb 100644
--- a/src/rustdoc/fold.rs
+++ b/src/rustdoc/fold.rs
@@ -71,18 +71,18 @@ fn mk_fold<T:Copy>(
 ) -> Fold<T> {
     Fold({
         ctxt: ctxt,
-        fold_doc: fold_doc,
-        fold_crate: fold_crate,
-        fold_item: fold_item,
-        fold_mod: fold_mod,
-        fold_nmod: fold_nmod,
-        fold_fn: fold_fn,
-        fold_const: fold_const,
-        fold_enum: fold_enum,
-        fold_trait: fold_trait,
-        fold_impl: fold_impl,
-        fold_type: fold_type,
-        fold_struct: fold_struct,
+        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
     })
 }
 
diff --git a/src/rustdoc/markdown_pass.rs b/src/rustdoc/markdown_pass.rs
index 924e4be6305..99357e254a4 100644
--- a/src/rustdoc/markdown_pass.rs
+++ b/src/rustdoc/markdown_pass.rs
@@ -9,13 +9,14 @@ export mk_pass;
 export header_kind, header_name, header_text;
 
 fn mk_pass(+writer_factory: WriterFactory) -> Pass {
-    let f = fn~(srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc {
+    let f = fn~(move writer_factory,
+                srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc {
         run(srv, doc, copy writer_factory)
     };
 
     {
         name: ~"markdown",
-        f: f
+        f: move f
     }
 }
 
@@ -44,7 +45,7 @@ fn run(
         ~"mods last", mods_last
     ).f(srv, doc);
 
-    write_markdown(sorted_doc, writer_factory);
+    write_markdown(sorted_doc, move writer_factory);
 
     return doc;
 }
@@ -84,8 +85,9 @@ fn write_markdown(
     doc: doc::Doc,
     +writer_factory: WriterFactory
 ) {
-    // FIXME #2484: There is easy parallelism to be had here but
-    // we don't want to spawn too many pandoc processes
+    // There is easy parallelism to be had here, but
+    // we don't want to spawn too many pandoc processes.
+    // (See #2484, which is closed.)
     do doc.pages.map |page| {
         let ctxt = {
             w: writer_factory(*page)
@@ -117,9 +119,9 @@ fn should_request_new_writer_for_each_page() {
     let (srv, doc) = test::create_doc_srv(~"mod a { }");
     // Split the document up into pages
     let doc = page_pass::mk_pass(config::DocPerMod).f(srv, doc);
-    write_markdown(doc, writer_factory);
+    write_markdown(doc, move writer_factory);
     // We expect two pages to have been written
-    for iter::repeat(2u) {
+    for iter::repeat(2) {
         comm::recv(po);
     }
 }
@@ -149,8 +151,8 @@ fn should_write_title_for_each_page() {
     let (srv, doc) = test::create_doc_srv(
         ~"#[link(name = \"core\")]; mod a { }");
     let doc = page_pass::mk_pass(config::DocPerMod).f(srv, doc);
-    write_markdown(doc, writer_factory);
-    for iter::repeat(2u) {
+    write_markdown(doc, move writer_factory);
+    for iter::repeat(2) {
         let (page, markdown) = comm::recv(po);
         match page {
           doc::CratePage(_) => {
@@ -844,7 +846,7 @@ mod test {
         doc: doc::Doc
     ) -> ~str {
         let (writer_factory, po) = markdown_writer::future_writer_factory();
-        write_markdown(doc, writer_factory);
+        write_markdown(doc, move writer_factory);
         return comm::recv(po).second();
     }
 
@@ -853,7 +855,7 @@ mod test {
         doc: doc::Doc
     ) -> ~str {
         let (writer_factory, po) = markdown_writer::future_writer_factory();
-        let pass = mk_pass(writer_factory);
+        let pass = mk_pass(move writer_factory);
         pass.f(srv, doc);
         return comm::recv(po).second();
     }
diff --git a/src/rustdoc/markdown_writer.rs b/src/rustdoc/markdown_writer.rs
index f505f9d0b99..1ed007def63 100644
--- a/src/rustdoc/markdown_writer.rs
+++ b/src/rustdoc/markdown_writer.rs
@@ -136,17 +136,20 @@ fn readclose(fd: libc::c_int) -> ~str {
     // Copied from run::program_output
     let file = os::fdopen(fd);
     let reader = io::FILE_reader(file, false);
-    let mut buf = ~"";
-    while !reader.eof() {
-        let bytes = reader.read_bytes(4096u);
-        buf += str::from_bytes(bytes);
-    }
+    let buf = io::with_bytes_writer(|writer| {
+        let mut bytes = [mut 0, ..4096];
+        while !reader.eof() {
+            let nread = reader.read(bytes, bytes.len());
+            writer.write(bytes.view(0, nread));
+        }
+    });
     os::fclose(file);
-    return buf;
+    str::from_bytes(buf)
 }
 
 fn generic_writer(+process: fn~(markdown: ~str)) -> Writer {
-    let ch = do task::spawn_listener |po: comm::Port<WriteInstr>| {
+    let ch = do task::spawn_listener
+        |move process, po: comm::Port<WriteInstr>| {
         let mut markdown = ~"";
         let mut keep_going = true;
         while keep_going {
@@ -155,7 +158,7 @@ fn generic_writer(+process: fn~(markdown: ~str)) -> Writer {
               Done => keep_going = false
             }
         }
-        process(markdown);
+        process(move markdown);
     };
 
     fn~(+instr: WriteInstr) {
@@ -274,22 +277,22 @@ fn future_writer_factory(
         let writer_ch = comm::Chan(&writer_po);
         do task::spawn {
             let (writer, future) = future_writer();
-            comm::send(writer_ch, writer);
+            comm::send(writer_ch, move writer);
             let s = future::get(&future);
             comm::send(markdown_ch, (page, s));
         }
         comm::recv(writer_po)
     };
 
-    (writer_factory, markdown_po)
+    (move writer_factory, markdown_po)
 }
 
 fn future_writer() -> (Writer, future::Future<~str>) {
     let (chan, port) = pipes::stream();
-    let writer = fn~(+instr: WriteInstr) {
+    let writer = fn~(move chan, +instr: WriteInstr) {
         chan.send(copy instr);
     };
-    let future = do future::from_fn {
+    let future = do future::from_fn |move port| {
         let mut res = ~"";
         loop {
             match port.recv() {
@@ -299,5 +302,5 @@ fn future_writer() -> (Writer, future::Future<~str>) {
         }
         res
     };
-    (writer, future)
+    (move writer, move future)
 }
diff --git a/src/rustdoc/page_pass.rs b/src/rustdoc/page_pass.rs
index ad3f679a97c..fc911d23e04 100644
--- a/src/rustdoc/page_pass.rs
+++ b/src/rustdoc/page_pass.rs
@@ -46,7 +46,7 @@ fn make_doc_from_pages(page_port: PagePort) -> doc::Doc {
     loop {
         let val = comm::recv(page_port);
         if val.is_some() {
-            pages += ~[option::unwrap(val)];
+            pages += ~[option::unwrap(move val)];
         } else {
             break;
         }
diff --git a/src/rustdoc/parse.rs b/src/rustdoc/parse.rs
index 59d64f18d59..7fc17dfe838 100644
--- a/src/rustdoc/parse.rs
+++ b/src/rustdoc/parse.rs
@@ -20,16 +20,16 @@ fn from_str(source: ~str) -> @ast::crate {
         ~"-", @source, ~[], parse::new_parse_sess(None))
 }
 
-fn from_file_sess(sess: session::session, file: &Path) -> @ast::crate {
+fn from_file_sess(sess: session::Session, file: &Path) -> @ast::crate {
     parse::parse_crate_from_file(
         file, cfg(sess, file_input(*file)), sess.parse_sess)
 }
 
-fn from_str_sess(sess: session::session, source: ~str) -> @ast::crate {
+fn from_str_sess(sess: session::Session, source: ~str) -> @ast::crate {
     parse::parse_crate_from_source_str(
         ~"-", @source, cfg(sess, str_input(source)), sess.parse_sess)
 }
 
-fn cfg(sess: session::session, input: driver::input) -> ast::crate_cfg {
+fn cfg(sess: session::Session, input: driver::input) -> ast::crate_cfg {
     driver::default_configuration(sess, ~"rustdoc", input)
 }
diff --git a/src/rustdoc/rustdoc.rc b/src/rustdoc/rustdoc.rc
index f8714b0e9ba..e8f0ec00545 100644
--- a/src/rustdoc/rustdoc.rc
+++ b/src/rustdoc/rustdoc.rc
@@ -1,7 +1,7 @@
 //! Rustdoc - The Rust documentation generator
 
 #[link(name = "rustdoc",
-       vers = "0.4",
+       vers = "0.5",
        uuid = "f8abd014-b281-484d-a0c3-26e3de8e2412",
        url = "https://github.com/mozilla/rust/tree/master/src/rustdoc")];
 
@@ -18,10 +18,10 @@
 #[allow(deprecated_mode)];
 #[allow(deprecated_pattern)];
 
-extern mod core(vers = "0.4");
-extern mod std(vers = "0.4");
-extern mod rustc(vers = "0.4");
-extern mod syntax(vers = "0.4");
+extern mod core(vers = "0.5");
+extern mod std(vers = "0.5");
+extern mod rustc(vers = "0.5");
+extern mod syntax(vers = "0.5");
 
 use core::*;
 use std::par;
diff --git a/src/rustdoc/rustdoc.rs b/src/rustdoc/rustdoc.rs
index b79b6ba2189..e09f57339a7 100755
--- a/src/rustdoc/rustdoc.rs
+++ b/src/rustdoc/rustdoc.rs
@@ -87,5 +87,5 @@ fn time<T>(what: ~str, f: fn() -> T) -> T {
     let rv = f();
     let end = std::time::precise_time_s();
     info!("time: %3.3f s    %s", end - start, what);
-    return rv;
+    move rv
 }
diff --git a/src/rustdoc/sort_pass.rs b/src/rustdoc/sort_pass.rs
index da3cf239538..d4d9e7e5156 100644
--- a/src/rustdoc/sort_pass.rs
+++ b/src/rustdoc/sort_pass.rs
@@ -10,7 +10,7 @@ type ItemLtEq = pure fn~(v1: &doc::ItemTag, v2:  &doc::ItemTag) -> bool;
 fn mk_pass(name: ~str, +lteq: ItemLtEq) -> Pass {
     {
         name: name,
-        f: fn~(srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc {
+        f: fn~(move lteq, srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc {
             run(srv, doc, lteq)
         }
     }
diff --git a/src/rustdoc/text_pass.rs b/src/rustdoc/text_pass.rs
index b929cd0aa91..f5ba9e9a2c9 100644
--- a/src/rustdoc/text_pass.rs
+++ b/src/rustdoc/text_pass.rs
@@ -7,7 +7,7 @@ export mk_pass;
 fn mk_pass(name: ~str, +op: fn~(~str) -> ~str) -> Pass {
     {
         name: name,
-        f: fn~(srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc {
+        f: fn~(move op, srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc {
             run(srv, doc, op)
         }
     }