librustc: Stop parsing modes and remove them entirely from the language

src/libcore/at_vec.rs

@@ -29,9 +29,9 @@ pub mod rustrt {
     #[abi = "cdecl"]
     #[link_name = "rustrt"]
     pub extern {
-        pub unsafe fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
+        pub unsafe fn vec_reserve_shared_actual(t: *sys::TypeDesc,
-                                                ++v: **vec::raw::VecRepr,
+                                                v: **vec::raw::VecRepr,
-                                                ++n: libc::size_t);
+                                                n: libc::size_t);
     }
 }
 
@@ -60,7 +60,7 @@ pub fn capacity<T>(v: @[T]) -> uint {
 pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> @[A] {
     let mut vec: @[A] = @[];
     unsafe { raw::reserve(&mut vec, size); }
-    builder(|+x| unsafe { raw::push(&mut vec, x) });
+    builder(|x| unsafe { raw::push(&mut vec, x) });
     return unsafe { transmute(vec) };
 }
 

src/libcore/cast.rs

@@ -17,7 +17,7 @@ pub mod rusti {
     #[abi = "rust-intrinsic"]
     #[link_name = "rusti"]
     pub extern "rust-intrinsic" {
-        fn forget<T>(+x: T);
+        fn forget<T>(x: T);
 
         fn transmute<T,U>(e: T) -> U;
     }

src/libcore/rt/uvll.rs

@@ -393,24 +393,26 @@ extern {
     // FIXME ref #2064
     fn rust_uv_tcp_connect(connect_ptr: *uv_connect_t,
                            tcp_handle_ptr: *uv_tcp_t,
-                           ++after_cb: *u8,
+                           after_cb: *u8,
-                           ++addr: *sockaddr_in) -> c_int;
+                           addr: *sockaddr_in) -> c_int;
     // FIXME ref #2064
-    fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t, ++addr: *sockaddr_in) -> c_int;
+    fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t, addr: *sockaddr_in) -> c_int;
     // FIXME ref #2064
     fn rust_uv_tcp_connect6(connect_ptr: *uv_connect_t,
                             tcp_handle_ptr: *uv_tcp_t,
-                            ++after_cb: *u8,
+                            after_cb: *u8,
-                            ++addr: *sockaddr_in6) -> c_int;
+                            addr: *sockaddr_in6) -> c_int;
     // FIXME ref #2064
-    fn rust_uv_tcp_bind6(tcp_server: *uv_tcp_t, ++addr: *sockaddr_in6) -> c_int;
+    fn rust_uv_tcp_bind6(tcp_server: *uv_tcp_t, addr: *sockaddr_in6) -> c_int;
-    fn rust_uv_tcp_getpeername(tcp_handle_ptr: *uv_tcp_t, ++name: *sockaddr_in) -> c_int;
+    fn rust_uv_tcp_getpeername(tcp_handle_ptr: *uv_tcp_t,
-    fn rust_uv_tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t, ++name: *sockaddr_in6) ->c_int;
+                               name: *sockaddr_in) -> c_int;
+    fn rust_uv_tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t,
+                                name: *sockaddr_in6) ->c_int;
     fn rust_uv_listen(stream: *c_void, backlog: c_int, cb: *u8) -> c_int;
     fn rust_uv_accept(server: *c_void, client: *c_void) -> c_int;
     fn rust_uv_write(req: *c_void,
                      stream: *c_void,
-                     ++buf_in: *uv_buf_t,
+                     buf_in: *uv_buf_t,
                      buf_cnt: c_int,
                      cb: *u8) -> c_int;
     fn rust_uv_read_start(stream: *c_void,
@@ -426,7 +428,7 @@ extern {
     fn rust_uv_timer_stop(handle: *uv_timer_t) -> c_int;
 
     fn rust_uv_malloc_buf_base_of(sug_size: size_t) -> *u8;
-    fn rust_uv_free_base_of_buf(++buf: uv_buf_t);
+    fn rust_uv_free_base_of_buf(buf: uv_buf_t);
     fn rust_uv_get_stream_handle_from_connect_req(connect_req: *uv_connect_t) -> *uv_stream_t;
     fn rust_uv_get_stream_handle_from_write_req(write_req: *uv_write_t) -> *uv_stream_t;
     fn rust_uv_get_loop_for_uv_handle(handle: *c_void) -> *c_void;
@@ -436,6 +438,6 @@ extern {
     fn rust_uv_set_data_for_uv_handle(handle: *c_void, data: *c_void);
     fn rust_uv_get_data_for_req(req: *c_void) -> *c_void;
     fn rust_uv_set_data_for_req(req: *c_void, data: *c_void);
-    fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8;
+    fn rust_uv_get_base_from_buf(buf: uv_buf_t) -> *u8;
-    fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> size_t;
+    fn rust_uv_get_len_from_buf(buf: uv_buf_t) -> size_t;
 }

src/libcore/stackwalk.rs

@@ -81,6 +81,6 @@ fn frame_address(f: &fn(x: *u8)) {
 pub mod rusti {
     #[abi = "rust-intrinsic"]
     pub extern "rust-intrinsic" {
-        pub fn frame_address(+f: &once fn(x: *u8));
+        pub fn frame_address(f: &once fn(x: *u8));
     }
 }

src/libcore/task/mod.rs

@@ -371,7 +371,7 @@ pub impl TaskBuilder {
         let (po, ch) = stream::<T>();
         let mut result = None;
 
-        self.future_result(|+r| { result = Some(r); });
+        self.future_result(|r| { result = Some(r); });
 
         do self.spawn {
             ch.send(f());
@@ -791,11 +791,11 @@ fn test_add_wrapper() {
 #[ignore(cfg(windows))]
 fn test_future_result() {
     let mut result = None;
-    do task().future_result(|+r| { result = Some(r); }).spawn { }
+    do task().future_result(|r| { result = Some(r); }).spawn { }
     assert!(result.unwrap().recv() == Success);
 
     result = None;
-    do task().future_result(|+r|
+    do task().future_result(|r|
         { result = Some(r); }).unlinked().spawn {
         fail!();
     }

src/libcore/unstable/intrinsics.rs

@@ -34,8 +34,8 @@ pub extern "rust-intrinsic" {
 
     pub fn size_of<T>() -> uint;
 
-    pub fn move_val<T>(dst: &mut T, +src: T);
+    pub fn move_val<T>(dst: &mut T, src: T);
-    pub fn move_val_init<T>(dst: &mut T, +src: T);
+    pub fn move_val_init<T>(dst: &mut T, src: T);
 
     pub fn min_align_of<T>() -> uint;
     pub fn pref_align_of<T>() -> uint;

src/libcore/vec.rs

@@ -42,13 +42,13 @@ pub mod rustrt {
         // These names are terrible. reserve_shared applies
         // to ~[] and reserve_shared_actual applies to @[].
         #[fast_ffi]
-        unsafe fn vec_reserve_shared(++t: *sys::TypeDesc,
+        unsafe fn vec_reserve_shared(t: *sys::TypeDesc,
-                                     ++v: **raw::VecRepr,
+                                     v: **raw::VecRepr,
-                                     ++n: libc::size_t);
+                                     n: libc::size_t);
         #[fast_ffi]
-        unsafe fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
+        unsafe fn vec_reserve_shared_actual(t: *sys::TypeDesc,
-                                            ++v: **raw::VecRepr,
+                                            v: **raw::VecRepr,
-                                            ++n: libc::size_t);
+                                            n: libc::size_t);
     }
 }
 

src/libfuzzer/fuzzer.rc

@@ -263,7 +263,7 @@ pub fn under(n: uint, it: &fn(uint)) {
     while i < n { it(i); i += 1u; }
 }
 
-pub fn as_str(f: @fn(+x: @io::Writer)) -> ~str {
+pub fn as_str(f: @fn(x: @io::Writer)) -> ~str {
     io::with_str_writer(f)
 }
 

src/librustc/back/upcall.rs

@@ -34,9 +34,9 @@ pub fn declare_upcalls(targ_cfg: @session::config,
     fn nothrow(f: ValueRef) -> ValueRef {
         base::set_no_unwind(f); f
     }
-    let d: &fn(+a: ~str, +b: ~[TypeRef], +c: TypeRef) -> ValueRef =
+    let d: &fn(a: ~str, b: ~[TypeRef], c: TypeRef) -> ValueRef =
         |a,b,c| decl(llmod, ~"upcall_", a, b, c);
-    let dv: &fn(+a: ~str, +b: ~[TypeRef]) -> ValueRef =
+    let dv: &fn(a: ~str, b: ~[TypeRef]) -> ValueRef =
         |a,b| decl(llmod, ~"upcall_", a, b, T_void());
 
     let int_t = T_int(targ_cfg);

src/librustc/front/intrinsic.rs

@@ -132,7 +132,7 @@ pub mod intrinsic {
         #[abi = "rust-intrinsic"]
         pub extern "rust-intrinsic" {
             pub fn get_tydesc<T>() -> *();
-            pub fn visit_tydesc(++td: *TyDesc, ++tv: @TyVisitor);
+            pub fn visit_tydesc(td: *TyDesc, tv: @TyVisitor);
         }
     }
 }

src/librustc/lib/llvm.rs

@@ -1561,12 +1561,18 @@ pub mod llvm {
                                        Name: *c_char) -> ValueRef;
 
         /* Atomic Operations */
-        pub unsafe fn LLVMBuildAtomicCmpXchg(B: BuilderRef, LHS: ValueRef,
+        pub unsafe fn LLVMBuildAtomicCmpXchg(B: BuilderRef,
-                                  CMP: ValueRef, RHS: ValueRef,
+                                             LHS: ValueRef,
-                                  ++Order: AtomicOrdering) -> ValueRef;
+                                             CMP: ValueRef,
-        pub unsafe fn LLVMBuildAtomicRMW(B: BuilderRef, ++Op: AtomicBinOp,
+                                             RHS: ValueRef,
-                              LHS: ValueRef, RHS: ValueRef,
+                                             Order: AtomicOrdering)
-                              ++Order: AtomicOrdering) -> ValueRef;
+                                             -> ValueRef;
+        pub unsafe fn LLVMBuildAtomicRMW(B: BuilderRef,
+                                         Op: AtomicBinOp,
+                                         LHS: ValueRef,
+                                         RHS: ValueRef,
+                                         Order: AtomicOrdering)
+                                         -> ValueRef;
 
         /* Selected entries from the downcasts. */
         #[fast_ffi]

src/librustdoc/extract.rs

@@ -22,7 +22,7 @@ use syntax;
  * there. */
 macro_rules! interner_key (
     () => (cast::transmute::<(uint, uint),
-           &fn(+v: @@syntax::parse::token::ident_interner)>((-3 as uint, 0u)))
+           &fn(v: @@syntax::parse::token::ident_interner)>((-3 as uint, 0u)))
 )
 
 // Hack; rather than thread an interner through everywhere, rely on

src/librustdoc/markdown_writer.rs

@@ -26,8 +26,8 @@ pub type Writer = ~fn(v: WriteInstr);
 pub type WriterFactory = ~fn(page: doc::Page) -> Writer;
 
 pub trait WriterUtils {
-    fn put_str(&self, +str: ~str);
+    fn put_str(&self, str: ~str);
-    fn put_line(&self, +str: ~str);
+    fn put_line(&self, str: ~str);
     fn put_done(&self);
 }
 

src/librustdoc/pass.rs

@@ -17,7 +17,7 @@ use time;
 /// A single operation on the document model
 pub struct Pass {
     name: ~str,
-    f: @fn(srv: astsrv::Srv, +doc: doc::Doc) -> doc::Doc
+    f: @fn(srv: astsrv::Srv, doc: doc::Doc) -> doc::Doc
 }
 
 pub fn run_passes(

src/libstd/arc.rs

@@ -673,8 +673,7 @@ mod tests {
         let mut children = ~[];
         for 5.times {
             let arc3 = (*arc).clone();
-            do task::task().future_result(|+r| children.push(r)).spawn
+            do task::task().future_result(|r| children.push(r)).spawn {
-                || {
                 do arc3.read |num| {
                     assert!(*num >= 0);
                 }

src/libstd/arena.rs

@@ -47,7 +47,7 @@ use core::vec;
 pub mod rusti {
     #[abi = "rust-intrinsic"]
     pub extern "rust-intrinsic" {
-        fn move_val_init<T>(dst: &mut T, +src: T);
+        fn move_val_init<T>(dst: &mut T, src: T);
         fn needs_drop<T>() -> bool;
     }
 }

src/libstd/flatpipes.rs

@@ -928,7 +928,7 @@ mod test {
             test_try_recv_none3(pipe_port_loader);
         }
 
-        fn test_try_recv_none4<P:BytePort>(+loader: PortLoader<P>) {
+        fn test_try_recv_none4<P:BytePort>(loader: PortLoader<P>) {
             assert!(do task::try || {
                 static CONTINUE: [u8, ..4] = [0xAA, 0xBB, 0xCC, 0xDD];
                 // The control word is followed by a valid length,

src/libstd/priority_queue.rs

@@ -14,7 +14,7 @@ use core::old_iter::BaseIter;
 
 #[abi = "rust-intrinsic"]
 extern "rust-intrinsic" mod rusti {
-    fn move_val_init<T>(dst: &mut T, +src: T);
+    fn move_val_init<T>(dst: &mut T, src: T);
     fn init<T>() -> T;
 }
 

src/libstd/test.rs

@@ -559,7 +559,7 @@ pub fn run_test(force_ignore: bool,
 
             let mut task = task::task();
             task.unlinked();
-            task.future_result(|+r| { result_future = Some(r) });
+            task.future_result(|r| { result_future = Some(r) });
             task.spawn(testfn_cell.take());
 
             let task_result = result_future.unwrap().recv();

src/libstd/uv_ll.rs

@@ -780,23 +780,24 @@ extern mod rustrt {
     // FIXME ref #2064
     unsafe fn rust_uv_tcp_connect(connect_ptr: *uv_connect_t,
                                   tcp_handle_ptr: *uv_tcp_t,
-                                  ++after_cb: *u8,
+                                  after_cb: *u8,
-                                  ++addr: *sockaddr_in) -> libc::c_int;
+                                  addr: *sockaddr_in)
+                                  -> libc::c_int;
     // FIXME ref #2064
     unsafe fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t,
-                               ++addr: *sockaddr_in) -> libc::c_int;
+                               addr: *sockaddr_in) -> libc::c_int;
     // FIXME ref #2064
     unsafe fn rust_uv_tcp_connect6(connect_ptr: *uv_connect_t,
                                    tcp_handle_ptr: *uv_tcp_t,
-                                   ++after_cb: *u8,
+                                   after_cb: *u8,
-                                   ++addr: *sockaddr_in6) -> libc::c_int;
+                                   addr: *sockaddr_in6) -> libc::c_int;
     // FIXME ref #2064
     unsafe fn rust_uv_tcp_bind6(tcp_server: *uv_tcp_t,
-                                ++addr: *sockaddr_in6) -> libc::c_int;
+                                addr: *sockaddr_in6) -> libc::c_int;
     unsafe fn rust_uv_tcp_getpeername(tcp_handle_ptr: *uv_tcp_t,
-                                      ++name: *sockaddr_in) -> libc::c_int;
+                                      name: *sockaddr_in) -> libc::c_int;
     unsafe fn rust_uv_tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t,
-                                       ++name: *sockaddr_in6) ->libc::c_int;
+                                       name: *sockaddr_in6) ->libc::c_int;
     unsafe fn rust_uv_listen(stream: *libc::c_void,
                              backlog: libc::c_int,
                              cb: *u8) -> libc::c_int;
@@ -804,7 +805,7 @@ extern mod rustrt {
                           -> libc::c_int;
     unsafe fn rust_uv_write(req: *libc::c_void,
                             stream: *libc::c_void,
-                            ++buf_in: *uv_buf_t,
+                            buf_in: *uv_buf_t,
                             buf_cnt: libc::c_int,
                             cb: *u8)
         -> libc::c_int;
@@ -843,7 +844,7 @@ extern mod rustrt {
     unsafe fn rust_uv_addrinfo_as_sockaddr_in6(input: *addrinfo)
         -> *sockaddr_in6;
     unsafe fn rust_uv_malloc_buf_base_of(sug_size: libc::size_t) -> *u8;
-    unsafe fn rust_uv_free_base_of_buf(++buf: uv_buf_t);
+    unsafe fn rust_uv_free_base_of_buf(buf: uv_buf_t);
     unsafe fn rust_uv_get_stream_handle_from_connect_req(
         connect_req: *uv_connect_t)
         -> *uv_stream_t;
@@ -864,8 +865,8 @@ extern mod rustrt {
         -> *libc::c_void;
     unsafe fn rust_uv_set_data_for_req(req: *libc::c_void,
                                        data: *libc::c_void);
-    unsafe fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8;
+    unsafe fn rust_uv_get_base_from_buf(buf: uv_buf_t) -> *u8;
-    unsafe fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> libc::size_t;
+    unsafe fn rust_uv_get_len_from_buf(buf: uv_buf_t) -> libc::size_t;
 
     // sizeof testing helpers
     unsafe fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint;
@@ -1258,7 +1259,7 @@ mod test {
 
     extern fn on_read_cb(stream: *uv_stream_t,
                         nread: libc::ssize_t,
-                        ++buf: uv_buf_t) {
+                        buf: uv_buf_t) {
         unsafe {
             let nread = nread as int;
             debug!("CLIENT entering on_read_cb nred: %d",
@@ -1444,7 +1445,7 @@ mod test {
 
     extern fn on_server_read_cb(client_stream_ptr: *uv_stream_t,
                                nread: libc::ssize_t,
-                               ++buf: uv_buf_t) {
+                               buf: uv_buf_t) {
         unsafe {
             let nread = nread as int;
             if (nread > 0) {

src/libsyntax/parse/parser.rs

@@ -390,8 +390,8 @@ pub impl Parser {
     // parse a ty_closure type
     fn parse_ty_closure(&self,
                         sigil: ast::Sigil,
-                        region: Option<@ast::Lifetime>) -> ty_
+                        region: Option<@ast::Lifetime>)
-    {
+                        -> ty_ {
         /*
 
         (&|~|@) ['r] [pure|unsafe] [once] fn <'lt> (S) -> T
@@ -773,20 +773,17 @@ pub impl Parser {
         return ty_rptr(opt_lifetime, mt);
     }
 
-    // parse an optional mode.
+    // parse an optional, obsolete argument mode.
-    // XXX: Remove after snapshot.
     fn parse_arg_mode(&self) {
         if self.eat(&token::BINOP(token::MINUS)) {
             self.obsolete(*self.span, ObsoleteMode);
         } else if self.eat(&token::ANDAND) {
-            // Ignore.
+            self.obsolete(*self.span, ObsoleteMode);
         } else if self.eat(&token::BINOP(token::PLUS)) {
             if self.eat(&token::BINOP(token::PLUS)) {
-                // ++ mode is obsolete, but we need a snapshot
+                self.obsolete(*self.span, ObsoleteMode);
-                // to stop parsing it.
-                // Ignore.
             } else {
-                // Ignore.
+                self.obsolete(*self.span, ObsoleteMode);
             }
         } else {
             // Ignore.

src/libsyntax/util/interner.rs

@@ -84,7 +84,7 @@ pub impl<T:Eq + IterBytes + Hash + Const + Copy> Interner<T> {
 * for another case of this. */
 macro_rules! interner_key (
     () => (cast::transmute::<(uint, uint),
-           &fn(+v: @@::parse::token::ident_interner)>(
+           &fn(v: @@::parse::token::ident_interner)>(
         (-3 as uint, 0u)))
 )