Remove capture clauses

src/librustc/middle/astencode.rs

@@ -821,7 +821,7 @@ fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
         let ebml_w = copy ebml_w;
         ast_util::visit_ids_for_inlined_item(
             ii,
-            fn@(id: ast::node_id, copy ebml_w) {
+            fn@(id: ast::node_id) {
                 // Note: this will cause a copy of ebml_w, which is bad as
                 // it has mut fields.  But I believe it's harmless since
                 // we generate balanced EBML.

src/librustdoc/text_pass.rs

@@ -76,7 +76,7 @@ fn apply_to_sections(
     op: NominalOp<Op>,
     sections: ~[doc::Section]
 ) -> ~[doc::Section] {
-    sections.map(|section, copy op| doc::Section {
+    sections.map(|section| doc::Section {
         header: (op.op)(copy section.header),
         body: (op.op)(copy section.body)
     })
@@ -89,7 +89,7 @@ fn fold_enum(
     let fold_copy = copy *fold;
 
     doc::EnumDoc {
-        variants: do doc.variants.map |variant, copy fold_copy| {
+        variants: do doc.variants.map |variant| {
             doc::VariantDoc {
                 desc: maybe_apply_op(copy fold_copy.ctxt, &variant.desc),
                 .. copy *variant

src/librustdoc/tystr_pass.rs

@@ -137,7 +137,7 @@ fn fold_enum(
         variants: do vec::map(doc.variants) |variant| {
             let sig = {
                 let variant = copy *variant;
-                do astsrv::exec(srv.clone()) |copy variant, ctxt| {
+                do astsrv::exec(srv.clone()) |ctxt| {
                     match ctxt.ast_map.get(&doc_id) {
                         ast_map::node_item(@ast::item {
                             node: ast::item_enum(ref enum_definition, _), _
@@ -198,7 +198,7 @@ fn get_method_sig(
     item_id: doc::AstId,
     method_name: ~str
 ) -> Option<~str> {
-    do astsrv::exec(srv) |copy method_name, ctxt| {
+    do astsrv::exec(srv) |ctxt| {
         match ctxt.ast_map.get(&item_id) {
           ast_map::node_item(@ast::item {
             node: ast::item_trait(_, _, ref methods), _

src/librusti/rusti.rc

@@ -368,7 +368,7 @@ fn run_line(repl: &mut Repl, in: io::Reader, out: io::Writer, line: ~str)
     }
 
     let r = *repl;
-    let result = do task::try |copy r| {
+    let result = do task::try {
         run(r, line)
     };
 

src/libstd/future.rs

@@ -202,7 +202,7 @@ pub mod test {
     #[test]
     pub fn test_sendable_future() {
         let expected = ~"schlorf";
-        let f = do spawn |copy expected| { copy expected };
+        let f = do spawn { copy expected };
         do task::spawn || {
             let actual = f.get();
             assert actual == expected;

src/libstd/par.rs

@@ -107,7 +107,7 @@ pub fn mapi<A: Copy Owned, B: Copy Owned>(
 {
     let slices = map_slices(xs, || {
         let f = fn_factory();
-        fn~(base: uint, slice : &[A], copy f) -> ~[B] {
+        fn~(base: uint, slice : &[A]) -> ~[B] {
             vec::mapi(slice, |i, x| {
                 f(i + base, x)
             })
@@ -126,7 +126,7 @@ pub fn alli<A: Copy Owned>(
 {
     do vec::all(map_slices(xs, || {
         let f = fn_factory();
-        fn~(base: uint, slice : &[A], copy f) -> bool {
+        fn~(base: uint, slice : &[A]) -> bool {
             vec::alli(slice, |i, x| {
                 f(i + base, x)
             })
@@ -140,7 +140,7 @@ pub fn any<A: Copy Owned>(
     fn_factory: &fn() -> ~fn(&A) -> bool) -> bool {
     do vec::any(map_slices(xs, || {
         let f = fn_factory();
-        fn~(_base : uint, slice: &[A], copy f) -> bool {
+        fn~(_base : uint, slice: &[A]) -> bool {
             vec::any(slice, |x| f(x))
         }
     })) |x| { *x }

src/libsyntax/parse/parser.rs

@@ -105,7 +105,6 @@ enum restriction {
 enum class_contents { dtor_decl(blk, ~[attribute], codemap::span),
                       members(~[@struct_field]) }
 
-type arg_or_capture_item = Either<arg, ()>;
 type item_info = (ident, item_, Option<~[attribute]>);
 
 pub enum item_or_view_item {
@@ -435,7 +434,7 @@ pub impl Parser {
             let (self_ty, d) = do self.parse_fn_decl_with_self() |p| {
                 // This is somewhat dubious; We don't want to allow argument
                 // names to be left off if there is a definition...
-                either::Left(p.parse_arg_general(false))
+                p.parse_arg_general(false)
             };
             // XXX: Wrong. Shouldn't allow both static and self_ty
             let self_ty = if is_static { static_sty } else { self_ty };
@@ -732,16 +731,8 @@ pub impl Parser {
         }
     }
 
-    fn parse_capture_item_or(parse_arg_fn: fn(Parser) -> arg_or_capture_item)
-        -> arg_or_capture_item
-    {
-        if self.eat_keyword(~"copy") {
-            // XXX outdated syntax now that moves-based-on-type has gone in
-            self.parse_ident();
-            either::Right(())
-        } else {
-            parse_arg_fn(self)
-        }
+    fn parse_arg() -> ast::arg {
+        self.parse_arg_general(true)
     }
 
     // This version of parse arg doesn't necessarily require
@@ -768,35 +759,26 @@ pub impl Parser {
                   ty: t, pat: pat, id: self.get_id() }
     }
 
-    fn parse_arg() -> arg_or_capture_item {
-        either::Left(self.parse_arg_general(true))
-    }
-
-    fn parse_arg_or_capture_item() -> arg_or_capture_item {
-        self.parse_capture_item_or(|p| p.parse_arg())
-    }
 
-    fn parse_fn_block_arg() -> arg_or_capture_item {
-        do self.parse_capture_item_or |p| {
-            let m = p.parse_arg_mode();
-            let is_mutbl = self.eat_keyword(~"mut");
-            let pat = p.parse_pat(false);
-            let t = if p.eat(token::COLON) {
-                p.parse_ty(false)
-            } else {
-                @Ty {
-                    id: p.get_id(),
-                    node: ty_infer,
-                    span: mk_sp(p.span.lo, p.span.hi),
-                }
-            };
-            either::Left(ast::arg {
-                mode: m,
-                is_mutbl: is_mutbl,
-                ty: t,
-                pat: pat,
-                id: p.get_id()
-            })
+    fn parse_fn_block_arg() -> ast::arg {
+        let m = self.parse_arg_mode();
+        let is_mutbl = self.eat_keyword(~"mut");
+        let pat = self.parse_pat(false);
+        let t = if self.eat(token::COLON) {
+            self.parse_ty(false)
+        } else {
+            @Ty {
+                id: self.get_id(),
+                node: ty_infer,
+                span: mk_sp(self.span.lo, self.span.hi),
+            }
+        };
+        ast::arg {
+            mode: m,
+            is_mutbl: is_mutbl,
+            ty: t,
+            pat: pat,
+            id: self.get_id()
         }
     }
 
@@ -1696,7 +1678,7 @@ pub impl Parser {
 
         // if we want to allow fn expression argument types to be inferred in
         // the future, just have to change parse_arg to parse_fn_block_arg.
-        let decl = self.parse_fn_decl(|p| p.parse_arg_or_capture_item());
+        let decl = self.parse_fn_decl(|p| p.parse_arg());
 
         let body = self.parse_block();
 
@@ -2678,19 +2660,17 @@ pub impl Parser {
         } else { ~[] }
     }
 
-    fn parse_fn_decl(parse_arg_fn: fn(Parser) -> arg_or_capture_item)
+    fn parse_fn_decl(parse_arg_fn: fn(Parser) -> ast::arg)
         -> fn_decl
     {
-        let args_or_capture_items: ~[arg_or_capture_item] =
+        let args: ~[ast::arg] =
             self.parse_unspanned_seq(
                 token::LPAREN, token::RPAREN,
                 seq_sep_trailing_disallowed(token::COMMA), parse_arg_fn);
 
-        let inputs = either::lefts(args_or_capture_items);
-
         let (ret_style, ret_ty) = self.parse_ret_ty();
         ast::fn_decl {
-            inputs: inputs,
+            inputs: args,
             output: ret_ty,
             cf: ret_style,
         }
@@ -2713,7 +2693,7 @@ pub impl Parser {
     }
 
     fn parse_fn_decl_with_self(parse_arg_fn:
-                               fn(Parser) -> arg_or_capture_item)
+                               fn(Parser) -> ast::arg)
                             -> (self_ty, fn_decl) {
 
         fn maybe_parse_self_ty(cnstr: fn(+v: mutability) -> ast::self_ty_,
@@ -2758,19 +2738,19 @@ pub impl Parser {
         };
 
         // If we parsed a self type, expect a comma before the argument list.
-        let args_or_capture_items;
+        let args;
         if self_ty != sty_by_ref {
             match copy self.token {
                 token::COMMA => {
                     self.bump();
                     let sep = seq_sep_trailing_disallowed(token::COMMA);
-                    args_or_capture_items =
+                    args =
                         self.parse_seq_to_before_end(token::RPAREN,
                                                      sep,
                                                      parse_arg_fn);
                 }
                 token::RPAREN => {
-                    args_or_capture_items = ~[];
+                    args = ~[];
                 }
                 _ => {
                     self.fatal(~"expected `,` or `)`, found `" +
@@ -2779,7 +2759,7 @@ pub impl Parser {
             }
         } else {
             let sep = seq_sep_trailing_disallowed(token::COMMA);
-            args_or_capture_items =
+            args =
                 self.parse_seq_to_before_end(token::RPAREN,
                                              sep,
                                              parse_arg_fn);
@@ -2789,11 +2769,10 @@ pub impl Parser {
 
         let hi = self.span.hi;
 
-        let inputs = either::lefts(args_or_capture_items);
         let (ret_style, ret_ty) = self.parse_ret_ty();
 
         let fn_decl = ast::fn_decl {
-            inputs: inputs,
+            inputs: args,
             output: ret_ty,
             cf: ret_style
         };
@@ -2802,7 +2781,7 @@ pub impl Parser {
     }
 
     fn parse_fn_block_decl() -> fn_decl {
-        let inputs_captures = {
+        let args = {
             if self.eat(token::OROR) {
                 ~[]
             } else {
@@ -2819,7 +2798,7 @@ pub impl Parser {
         };
 
         ast::fn_decl {
-            inputs: either::lefts(inputs_captures),
+            inputs: args,
             output: output,
             cf: return_val,
         }

src/test/auxiliary/cci_capture_clause.rs

@@ -12,7 +12,7 @@ use core::pipes::*;
 
 pub fn foo<T: Owned Copy>(x: T) -> Port<T> {
     let (p, c) = stream();
-    do task::spawn() |copy x| {
+    do task::spawn() {
         c.send(x);
     }
     p

src/test/compile-fail/kindck-nonsendable-1.rs

@@ -13,6 +13,6 @@ fn foo(_x: @uint) {}
 fn main() {
     let x = @3u;
     let _ = fn~() { foo(x); }; //~ ERROR value has non-owned type `@uint`
-    let _ = fn~(copy x) { foo(x); }; //~ ERROR value has non-owned type `@uint`
+    let _ = fn~() { foo(x); }; //~ ERROR value has non-owned type `@uint`
     let _ = fn~() { foo(x); }; //~ ERROR value has non-owned type `@uint`
 }

src/test/run-pass/capture_nil.rs

@@ -28,7 +28,7 @@ use core::pipes::*;
 
 fn foo(&&x: ()) -> Port<()> {
     let (p, c) = stream::<()>();
-    do task::spawn() |copy x| {
+    do task::spawn() {
         c.send(x);
     }
     p

src/test/run-pass/issue-3609.rs

@@ -12,7 +12,6 @@ enum Msg
 
 fn foo(name: ~str, samples_chan: Chan<Msg>) {
     do task::spawn
-    |copy name|
     {
         let callback: SamplesFn =
             |buffer|