librustdoc: Get rid of move.

Author: luqmana

src/librustdoc/astsrv.rs

@@ -91,7 +91,7 @@ fn run<T>(owner: SrvOwner<T>, source: ~str, parse: Parser) -> T {
 
     let res = owner(srv_.clone());
     srv_.ch.send(Exit);
-    move res
+    res
 }
 
 fn act(po: &Port<Msg>, source: ~str, parse: Parser) {
@@ -120,10 +120,10 @@ pub fn exec<T:Owned>(
     f: fn~(ctxt: Ctxt) -> T
 ) -> T {
     let (po, ch) = stream();
-    let msg = HandleRequest(fn~(move f, ctxt: Ctxt) {
+    let msg = HandleRequest(fn~(ctxt: Ctxt) {
         ch.send(f(ctxt))
     });
-    srv.ch.send(move msg);
+    srv.ch.send(msg);
     po.recv()
 }
 

src/librustdoc/attr_pass.rs

@@ -115,7 +115,7 @@ fn parse_item_attrs<T:Owned>(
     srv: astsrv::Srv,
     id: doc::AstId,
     parse_attrs: fn~(a: ~[ast::attribute]) -> T) -> T {
-    do astsrv::exec(srv) |move parse_attrs, ctxt| {
+    do astsrv::exec(srv) |ctxt| {
         let attrs = match ctxt.ast_map.get(&id) {
           ast_map::node_item(item, _) => copy item.attrs,
           ast_map::node_foreign_item(item, _, _) => copy item.attrs,

src/librustdoc/config.rs

@@ -133,7 +133,7 @@ pub fn parse_config_(
         result::Ok(matches) => {
             if matches.free.len() == 1 {
                 let input_crate = Path(vec::head(matches.free));
-                config_from_opts(&input_crate, &matches, move program_output)
+                config_from_opts(&input_crate, &matches, program_output)
             } else if matches.free.is_empty() {
                 result::Err(~"no crates specified")
             } else {
@@ -191,11 +191,11 @@ fn config_from_opts(
             }
         }
     };
-    let program_output = Cell(move program_output);
+    let program_output = Cell(program_output);
     let result = do result::chain(result) |config| {
         let pandoc_cmd = getopts::opt_maybe_str(matches, opt_pandoc_cmd());
         let pandoc_cmd = maybe_find_pandoc(
-            &config, pandoc_cmd, move program_output.take());
+            &config, pandoc_cmd, program_output.take());
         do result::chain(pandoc_cmd) |pandoc_cmd| {
             result::Ok(Config {
                 pandoc_cmd: pandoc_cmd,
@@ -268,7 +268,7 @@ fn should_find_pandoc() {
             status: 0, out: ~"pandoc 1.8.2.1", err: ~""
         }
     };
-    let result = maybe_find_pandoc(&config, None, move mock_program_output);
+    let result = maybe_find_pandoc(&config, None, mock_program_output);
     assert result == result::Ok(Some(~"pandoc"));
 }
 
@@ -284,7 +284,7 @@ fn should_error_with_no_pandoc() {
             status: 1, out: ~"", err: ~""
         }
     };
-    let result = maybe_find_pandoc(&config, None, move mock_program_output);
+    let result = maybe_find_pandoc(&config, None, mock_program_output);
     assert result == result::Err(~"couldn't find pandoc");
 }
 

src/librustdoc/fold.rs

@@ -87,25 +87,25 @@ fn mk_fold<T>(
     fold_struct: FoldStruct<T>
 ) -> Fold<T> {
     Fold {
-        ctxt: move ctxt,
-        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
+        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
     }
 }
 
 pub fn default_any_fold<T: Clone>(ctxt: T) -> Fold<T> {
     mk_fold(
-        move ctxt,
+        ctxt,
         |f, d| default_seq_fold_doc(f, d),
         |f, d| default_seq_fold_crate(f, d),
         |f, d| default_seq_fold_item(f, d),
@@ -123,7 +123,7 @@ pub fn default_any_fold<T: Clone>(ctxt: T) -> Fold<T> {
 
 pub fn default_seq_fold<T: Clone>(ctxt: T) -> Fold<T> {
     mk_fold(
-        move ctxt,
+        ctxt,
         |f, d| default_seq_fold_doc(f, d),
         |f, d| default_seq_fold_crate(f, d),
         |f, d| default_seq_fold_item(f, d),
@@ -141,7 +141,7 @@ pub fn default_seq_fold<T: Clone>(ctxt: T) -> Fold<T> {
 
 pub fn default_par_fold<T: Clone>(ctxt: T) -> Fold<T> {
     mk_fold(
-        move ctxt,
+        ctxt,
         |f, d| default_seq_fold_doc(f, d),
         |f, d| default_seq_fold_crate(f, d),
         |f, d| default_seq_fold_item(f, d),

src/librustdoc/markdown_pass.rs

@@ -74,7 +74,7 @@ fn run(
         ~"mods last", mods_last
     ).f)(srv, copy doc);
 
-    write_markdown(sorted_doc, move writer_factory);
+    write_markdown(sorted_doc, writer_factory);
 
     return doc;
 }
@@ -148,7 +148,7 @@ 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, move writer_factory);
+    write_markdown(doc, writer_factory);
     // We expect two pages to have been written
     for iter::repeat(2) {
         po.recv();
@@ -180,7 +180,7 @@ 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, move writer_factory);
+    write_markdown(doc, writer_factory);
     for iter::repeat(2) {
         let (page, markdown) = po.recv();
         match page {
@@ -894,7 +894,7 @@ mod test {
         doc: doc::Doc
     ) -> ~str {
         let (writer_factory, po) = markdown_writer::future_writer_factory();
-        write_markdown(doc, move writer_factory);
+        write_markdown(doc, writer_factory);
         return po.recv().second();
     }
 
@@ -903,7 +903,7 @@ mod test {
         doc: doc::Doc
     ) -> ~str {
         let (writer_factory, po) = markdown_writer::future_writer_factory();
-        let pass = mk_pass(move writer_factory);
+        let pass = mk_pass(writer_factory);
         (pass.f)(srv, doc);
         return po.recv().second();
     }

src/librustdoc/markdown_writer.rs

@@ -129,12 +129,12 @@ fn pandoc_writer(
         os::close(pipe_in.out);
 
         let (stdout_po, stdout_ch) = pipes::stream();
-        do task::spawn_sched(task::SingleThreaded) |move stdout_ch| {
+        do task::spawn_sched(task::SingleThreaded) || {
             stdout_ch.send(readclose(pipe_out.in));
         }
 
         let (stderr_po, stderr_ch) = pipes::stream();
-        do task::spawn_sched(task::SingleThreaded) |move stderr_ch| {
+        do task::spawn_sched(task::SingleThreaded) || {
             stderr_ch.send(readclose(pipe_err.in));
         }
         let stdout = stdout_po.recv();
@@ -169,7 +169,7 @@ fn readclose(fd: libc::c_int) -> ~str {
 
 fn generic_writer(process: fn~(markdown: ~str)) -> Writer {
     let (po, ch) = stream::<WriteInstr>();
-    do task::spawn |move process, move setup_ch| {
+    do task::spawn || {
         let mut markdown = ~"";
         let mut keep_going = true;
         while keep_going {
@@ -178,7 +178,7 @@ fn generic_writer(process: fn~(markdown: ~str)) -> Writer {
               Done => keep_going = false
             }
         }
-        process(move markdown);
+        process(markdown);
     };
     fn~(instr: WriteInstr) {
         ch.send(instr);
@@ -298,24 +298,24 @@ pub fn future_writer_factory(
     let writer_factory = fn~(page: doc::Page) -> Writer {
         let (writer_po, writer_ch) = pipes::stream();
         let markdown_ch = markdown_ch.clone();
-        do task::spawn |move writer_ch| {
+        do task::spawn || {
             let (writer, future) = future_writer();
-            writer_ch.send(move writer);
+            writer_ch.send(writer);
             let s = future.get();
             markdown_ch.send((copy page, s));
         }
         writer_po.recv()
     };
 
-    (move writer_factory, markdown_po)
+    (writer_factory, markdown_po)
 }
 
 fn future_writer() -> (Writer, future::Future<~str>) {
     let (port, chan) = pipes::stream();
-    let writer = fn~(move chan, instr: WriteInstr) {
+    let writer = fn~(instr: WriteInstr) {
         chan.send(copy instr);
     };
-    let future = do future::from_fn |move port| {
+    let future = do future::from_fn || {
         let mut res = ~"";
         loop {
             match port.recv() {
@@ -325,5 +325,5 @@ fn future_writer() -> (Writer, future::Future<~str>) {
         }
         res
     };
-    (move writer, move future)
+    (writer, future)
 }

src/librustdoc/page_pass.rs

@@ -71,7 +71,7 @@ fn make_doc_from_pages(page_port: &PagePort) -> doc::Doc {
     loop {
         let val = page_port.recv();
         if val.is_some() {
-            pages += ~[option::unwrap(move val)];
+            pages += ~[option::unwrap(val)];
         } else {
             break;
         }

src/librustdoc/path_pass.rs

@@ -54,7 +54,7 @@ fn run(srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc {
         fold_item: fold_item,
         fold_mod: fold_mod,
         fold_nmod: fold_nmod,
-        .. fold::default_any_fold(move ctxt)
+        .. fold::default_any_fold(ctxt)
     };
     (fold.fold_doc)(&fold, doc)
 }

src/librustdoc/rustdoc.rc

@@ -149,5 +149,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);
-    move rv
+    rv
 }

src/librustdoc/sort_pass.rs

@@ -42,7 +42,7 @@ fn run(
 ) -> doc::Doc {
     let fold = Fold {
         fold_mod: fold_mod,
-        .. fold::default_any_fold(move lteq)
+        .. fold::default_any_fold(lteq)
     };
     (fold.fold_doc)(&fold, doc)
 }

src/librustdoc/text_pass.rs

@@ -42,14 +42,14 @@ fn run(
     op: Op
 ) -> doc::Doc {
     let op = NominalOp {
-        op: move op
+        op: op
     };
     let fold = Fold {
         fold_item: fold_item,
         fold_enum: fold_enum,
         fold_trait: fold_trait,
         fold_impl: fold_impl,
-        .. fold::default_any_fold(move op)
+        .. fold::default_any_fold(op)
     };
     (fold.fold_doc)(&fold, doc)
 }