librustc: Make `||` lambdas not infer to `proc`s

doc/tutorial-tasks.md

@@ -76,7 +76,7 @@ fn print_message() { println("I am running in a different task!"); }
 spawn(print_message);
 
 // Print something more profound in a different task using a lambda expression
-spawn( || println("I am also running in a different task!") );
+spawn(proc() println("I am also running in a different task!") );
 
 // The canonical way to spawn is using `do` notation
 do spawn {
@@ -278,7 +278,7 @@ fn fib(n: u64) -> u64 {
     12586269025
 }
 
-let mut delayed_fib = extra::future::Future::spawn (|| fib(50) );
+let mut delayed_fib = extra::future::Future::spawn(proc() fib(50));
 make_a_sandwich();
 println!("fib(50) = {:?}", delayed_fib.get())
 ~~~

src/compiletest/compiletest.rs

@@ -333,7 +333,7 @@ pub fn make_test_closure(config: &config, testfile: &Path) -> test::TestFn {
     let config = Cell::new((*config).clone());
     // FIXME (#9639): This needs to handle non-utf8 paths
     let testfile = Cell::new(testfile.as_str().unwrap().to_owned());
-    test::DynTestFn(|| { runtest::run(config.take(), testfile.take()) })
+    test::DynTestFn(proc() { runtest::run(config.take(), testfile.take()) })
 }
 
 pub fn make_metrics_test_closure(config: &config, testfile: &Path) -> test::TestFn {
@@ -341,5 +341,7 @@ pub fn make_metrics_test_closure(config: &config, testfile: &Path) -> test::Test
     let config = Cell::new((*config).clone());
     // FIXME (#9639): This needs to handle non-utf8 paths
     let testfile = Cell::new(testfile.as_str().unwrap().to_owned());
-    test::DynMetricFn(|mm| { runtest::run_metrics(config.take(), testfile.take(), mm) })
+    test::DynMetricFn(proc(mm) {
+        runtest::run_metrics(config.take(), testfile.take(), mm)
+    })
 }

src/libextra/future.rs

@@ -161,7 +161,7 @@ fn test_from_port() {
 
     #[test]
     fn test_from_fn() {
-        let mut f = Future::from_fn(|| ~"brail");
+        let mut f = Future::from_fn(proc() ~"brail");
         assert_eq!(f.get(), ~"brail");
     }
 
@@ -185,14 +185,14 @@ fn test_get_ref_method() {
 
     #[test]
     fn test_spawn() {
-        let mut f = Future::spawn(|| ~"bale");
+        let mut f = Future::spawn(proc() ~"bale");
         assert_eq!(f.get(), ~"bale");
     }
 
     #[test]
     #[should_fail]
     fn test_futurefail() {
-        let mut f = Future::spawn(|| fail!());
+        let mut f = Future::spawn(proc() fail!());
         let _x: ~str = f.get();
     }
 

src/libextra/task_pool.rs

@@ -57,7 +57,7 @@ pub fn new(n_tasks: uint,
             let (port, chan) = comm::stream::<Msg<T>>();
             let init_fn = init_fn_factory();
 
-            let task_body: proc() = || {
+            let task_body: proc() = proc() {
                 let local_data = init_fn(i);
                 loop {
                     match port.recv() {
@@ -98,11 +98,11 @@ pub fn execute(&mut self, f: proc(&T)) {
 #[test]
 fn test_task_pool() {
     let f: || -> proc(uint) -> uint = || {
-        let g: proc(uint) -> uint = |i| i;
+        let g: proc(uint) -> uint = proc(i) i;
         g
     };
     let mut pool = TaskPool::new(4, Some(SingleThreaded), f);
     8.times(|| {
-        pool.execute(|i| println!("Hello from thread {}!", *i));
+        pool.execute(proc(i) println!("Hello from thread {}!", *i));
     })
 }

src/libextra/test.rs

@@ -912,7 +912,7 @@ fn run_test_inner(desc: TestDesc,
             return;
         }
         DynTestFn(f) => run_test_inner(desc, monitor_ch, f),
-        StaticTestFn(f) => run_test_inner(desc, monitor_ch, || f())
+        StaticTestFn(f) => run_test_inner(desc, monitor_ch, proc() f())
     }
 }
 
@@ -1209,7 +1209,7 @@ pub fn do_not_run_ignored_tests() {
                 ignore: true,
                 should_fail: false
             },
-            testfn: DynTestFn(|| f()),
+            testfn: DynTestFn(proc() f()),
         };
         let (p, ch) = stream();
         let ch = SharedChan::new(ch);
@@ -1227,7 +1227,7 @@ fn f() { }
                 ignore: true,
                 should_fail: false
             },
-            testfn: DynTestFn(|| f()),
+            testfn: DynTestFn(proc() f()),
         };
         let (p, ch) = stream();
         let ch = SharedChan::new(ch);
@@ -1245,7 +1245,7 @@ fn test_should_fail() {
                 ignore: false,
                 should_fail: true
             },
-            testfn: DynTestFn(|| f()),
+            testfn: DynTestFn(proc() f()),
         };
         let (p, ch) = stream();
         let ch = SharedChan::new(ch);
@@ -1263,7 +1263,7 @@ fn f() { }
                 ignore: false,
                 should_fail: true
             },
-            testfn: DynTestFn(|| f()),
+            testfn: DynTestFn(proc() f()),
         };
         let (p, ch) = stream();
         let ch = SharedChan::new(ch);
@@ -1318,7 +1318,7 @@ fn dummy() {}
                     ignore: true,
                     should_fail: false,
                 },
-                testfn: DynTestFn(|| {}),
+                testfn: DynTestFn(proc() {}),
             },
             TestDescAndFn {
                 desc: TestDesc {
@@ -1326,7 +1326,7 @@ fn dummy() {}
                     ignore: false,
                     should_fail: false
                 },
-                testfn: DynTestFn(|| {}),
+                testfn: DynTestFn(proc() {}),
             },
         ];
         let filtered = filter_tests(&opts, tests);

src/librustc/lib.rs

@@ -345,7 +345,7 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
         task_builder.opts.stack_size = Some(STACK_SIZE);
     }
 
-    match task_builder.try(|| {
+    match task_builder.try(proc() {
         let ch = ch_capture.clone();
         // The 'diagnostics emitter'. Every error, warning, etc. should
         // go through this function.
@@ -403,6 +403,6 @@ pub fn main() {
 
 pub fn main_args(args: &[~str]) -> int {
     let owned_args = args.to_owned();
-    monitor(|demitter| run_compiler(owned_args, demitter));
+    monitor(proc(demitter) run_compiler(owned_args, demitter));
     0
 }

src/librustc/middle/typeck/check/mod.rs

@@ -2905,8 +2905,13 @@ fn check_struct_enum_variant(fcx: @mut FnCtxt,
         _match::check_match(fcx, expr, discrim, *arms);
       }
       ast::ExprFnBlock(ref decl, ref body) => {
-        check_expr_fn(fcx, expr, None,
-                      decl, body, Vanilla, expected);
+        check_expr_fn(fcx,
+                      expr,
+                      Some(ast::BorrowedSigil),
+                      decl,
+                      body,
+                      Vanilla,
+                      expected);
       }
       ast::ExprProc(ref decl, ref body) => {
         check_expr_fn(fcx,

src/librustpkg/lib.rs

@@ -474,7 +474,7 @@ fn build(&self, pkg_src: &mut PkgSrc, what_to_build: &WhatToBuild) {
                     let psp = package_script_path.clone();
                     let ws = workspace.clone();
                     let pid = pkgid.clone();
-                    prep.exec(|exec| {
+                    prep.exec(proc(exec) {
                         let mut pscript = PkgScript::parse(subsysroot.clone(),
                                                            psp.clone(),
                                                            &ws,
@@ -636,7 +636,7 @@ fn install_no_build(&self,
             let sub_target_ex = target_exec.clone();
             let sub_target_lib = target_lib.clone();
             let sub_build_inputs = build_inputs.to_owned();
-            prep.exec(|exe_thing| {
+            prep.exec(proc(exe_thing) {
                 let mut outputs = ~[];
                 // Declare all the *inputs* to the declared input too, as inputs
                 for executable in subex.iter() {

src/librustpkg/package_source.rs

@@ -412,7 +412,7 @@ fn build_crates(&self,
                 let sub_deps = deps.clone();
                 let inputs = inputs_to_discover.map(|&(ref k, ref p)|
                                                     (k.clone(), p.as_str().unwrap().to_owned()));
-                prep.exec(|exec| {
+                prep.exec(proc(exec) {
                     for &(ref kind, ref p) in inputs.iter() {
                         let pth = Path::new(p.clone());
                         exec.discover_input(*kind, *p, if *kind == ~"file" {

src/librustuv/net.rs

@@ -1092,7 +1092,7 @@ fn test_simple_homed_udp_io_bind_then_move_task_then_home_and_close() {
             let handle2 = Cell::new(sched2.make_handle());
             let tasksFriendHandle = Cell::new(sched2.make_handle());
 
-            let on_exit: proc(UnwindResult) = |exit_status| {
+            let on_exit: proc(UnwindResult) = proc(exit_status) {
                 handle1.take().send(Shutdown);
                 handle2.take().send(Shutdown);
                 assert!(exit_status.is_success());
@@ -1106,7 +1106,7 @@ unsafe fn local_io() -> &'static mut IoFactory {
                 })
             }
 
-            let test_function: proc() = || {
+            let test_function: proc() = proc() {
                 let io = unsafe { local_io() };
                 let addr = next_test_ip4();
                 let maybe_socket = io.udp_bind(addr);

src/libstd/io/net/unix.rs

@@ -214,29 +214,29 @@ fn connect_error() {
 
     #[test]
     fn smoke() {
-        smalltest(|mut server| {
+        smalltest(proc(mut server) {
             let mut buf = [0];
             server.read(buf);
             assert!(buf[0] == 99);
-        }, |mut client| {
+        }, proc(mut client) {
             client.write([99]);
         })
     }
 
     #[test]
     fn read_eof() {
-        smalltest(|mut server| {
+        smalltest(proc(mut server) {
             let mut buf = [0];
             assert!(server.read(buf).is_none());
             assert!(server.read(buf).is_none());
-        }, |_client| {
+        }, proc(_client) {
             // drop the client
         })
     }
 
     #[test]
     fn write_begone() {
-        smalltest(|mut server| {
+        smalltest(proc(mut server) {
             let buf = [0];
             let mut stop = false;
             while !stop{
@@ -248,7 +248,7 @@ fn write_begone() {
                     server.write(buf);
                 })
             }
-        }, |_client| {
+        }, proc(_client) {
             // drop the client
         })
     }

src/libstd/rt/local.rs

@@ -134,7 +134,7 @@ fn thread_local_task_smoke_test() {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
@@ -146,11 +146,11 @@ fn thread_local_task_two_instances() {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
-            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
@@ -163,7 +163,7 @@ fn borrow_smoke_test() {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
 
             unsafe {
@@ -179,7 +179,7 @@ fn borrow_with_return() {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
 
             let res = Local::borrow(|_task: &mut Task| {

src/libstd/rt/mod.rs

@@ -340,14 +340,14 @@ fn run_(main: proc(), use_main_sched: bool) -> int {
 
     // When the main task exits, after all the tasks in the main
     // task tree, shut down the schedulers and set the exit code.
-    let handles = Cell::new(handles);
-    let on_exit: proc(UnwindResult) = |exit_success| {
+    let handles = handles;
+    let on_exit: proc(UnwindResult) = proc(exit_success) {
         unsafe {
             assert!(!(*exited_already.get()).swap(true, SeqCst),
                     "the runtime already exited");
         }
 
-        let mut handles = handles.take();
+        let mut handles = handles;
         for handle in handles.mut_iter() {
             handle.send(Shutdown);
         }

src/libstd/rt/sched.rs

@@ -979,7 +979,7 @@ fn test_home_sched() {
                 assert!(Task::on_appropriate_sched());
             };
 
-            let on_exit: proc(UnwindResult) = |exit_status| {
+            let on_exit: proc(UnwindResult) = proc(exit_status) {
                 rtassert!(exit_status.is_success())
             };
             task.death.on_exit = Some(on_exit);
@@ -1193,12 +1193,15 @@ fn no_missed_messages() {
 
                 let thread = do Thread::start {
                     let mut sched = sched.take();
-                    let bootstrap_task = ~Task::new_root(&mut sched.stack_pool, None, ||());
+                    let bootstrap_task =
+                        ~Task::new_root(&mut sched.stack_pool,
+                                        None,
+                                        proc()());
                     sched.bootstrap(bootstrap_task);
                 };
 
                 let mut stack_pool = StackPool::new();
-                let task = ~Task::new_root(&mut stack_pool, None, ||());
+                let task = ~Task::new_root(&mut stack_pool, None, proc()());
                 handle.send(TaskFromFriend(task));
 
                 handle.send(Shutdown);

src/libstd/rt/task.rs

@@ -425,7 +425,7 @@ pub fn empty() -> Coroutine {
 
     fn build_start_wrapper(start: proc()) -> proc() {
         let start_cell = Cell::new(start);
-        let wrapper: proc() = || {
+        let wrapper: proc() = proc() {
             // First code after swap to this new context. Run our
             // cleanup job.
             unsafe {
@@ -712,10 +712,10 @@ fn tls() {
     #[test]
     fn unwind() {
         do run_in_newsched_task() {
-            let result = spawntask_try(||());
+            let result = spawntask_try(proc()());
             rtdebug!("trying first assert");
             assert!(result.is_ok());
-            let result = spawntask_try(|| fail!());
+            let result = spawntask_try(proc() fail!());
             rtdebug!("trying second assert");
             assert!(result.is_err());
         }

src/libstd/rt/test.rs

@@ -83,10 +83,11 @@ pub fn run_in_uv_task_core(f: proc()) {
     use rt::sched::Shutdown;
 
     let mut sched = ~new_test_uv_sched();
-    let exit_handle = Cell::new(sched.make_handle());
+    let exit_handle = sched.make_handle();
 
-    let on_exit: proc(UnwindResult) = |exit_status| {
-        exit_handle.take().send(Shutdown);
+    let on_exit: proc(UnwindResult) = proc(exit_status: UnwindResult) {
+        let mut exit_handle = exit_handle;
+        exit_handle.send(Shutdown);
         rtassert!(exit_status.is_success());
     };
     let mut task = ~Task::new_root(&mut sched.stack_pool, None, f);
@@ -99,10 +100,11 @@ pub fn run_in_newsched_task_core(f: proc()) {
     use rt::sched::Shutdown;
 
     let mut sched = ~new_test_sched();
-    let exit_handle = Cell::new(sched.make_handle());
+    let exit_handle = sched.make_handle();
 
-    let on_exit: proc(UnwindResult) = |exit_status| {
-        exit_handle.take().send(Shutdown);
+    let on_exit: proc(UnwindResult) = proc(exit_status: UnwindResult) {
+        let mut exit_handle = exit_handle;
+        exit_handle.send(Shutdown);
         rtassert!(exit_status.is_success());
     };
     let mut task = ~Task::new_root(&mut sched.stack_pool, None, f);
@@ -244,10 +246,10 @@ pub fn run_in_mt_newsched_task(f: proc()) {
             scheds.push(sched);
         }
 
-        let handles = Cell::new(handles);
-        let on_exit: proc(UnwindResult) = |exit_status| {
-            let mut handles = handles.take();
+        let handles = handles;  // Work around not being able to capture mut
+        let on_exit: proc(UnwindResult) = proc(exit_status: UnwindResult) {
             // Tell schedulers to exit
+            let mut handles = handles;
             for handle in handles.mut_iter() {
                 handle.send(Shutdown);
             }
@@ -319,8 +321,9 @@ pub fn spawntask_random(f: proc()) {
 pub fn spawntask_try(f: proc()) -> Result<(),()> {
 
     let (port, chan) = oneshot();
-    let chan = Cell::new(chan);
-    let on_exit: proc(UnwindResult) = |exit_status| chan.take().send(exit_status);
+    let on_exit: proc(UnwindResult) = proc(exit_status) {
+        chan.send(exit_status)
+    };
 
     let mut new_task = Task::build_root(None, f);
     new_task.death.on_exit = Some(on_exit);
@@ -348,7 +351,9 @@ pub fn spawntask_thread(f: proc()) -> Thread {
 pub fn with_test_task(blk: proc(~Task) -> ~Task) {
     do run_in_bare_thread {
         let mut sched = ~new_test_sched();
-        let task = blk(~Task::new_root(&mut sched.stack_pool, None, ||{}));
+        let task = blk(~Task::new_root(&mut sched.stack_pool,
+                                       None,
+                                       proc() {}));
         cleanup_task(task);
     }
 }

src/libstd/task/mod.rs

@@ -280,13 +280,13 @@ pub fn add_wrapper(&mut self, wrapper: proc(v: proc()) -> proc()) {
         let prev_gen_body = match prev_gen_body {
             Some(gen) => gen,
             None => {
-                let f: proc(proc()) -> proc() = |body| body;
+                let f: proc(proc()) -> proc() = proc(body) body;
                 f
             }
         };
         let prev_gen_body = Cell::new(prev_gen_body);
         let next_gen_body = {
-            let f: proc(proc()) -> proc() = |body| {
+            let f: proc(proc()) -> proc() = proc(body) {
                 let prev_gen_body = prev_gen_body.take();
                 wrapper(prev_gen_body(body))
             };
@@ -551,7 +551,7 @@ fn test_add_wrapper() {
     let ch = Cell::new(ch);
     do b0.add_wrapper |body| {
         let ch = Cell::new(ch.take());
-        let result: proc() = || {
+        let result: proc() = proc() {
             let ch = ch.take();
             body();
             ch.send(());
@@ -765,7 +765,7 @@ fn test_child_doesnt_ref_parent() {
     // valgrind-friendly. try this at home, instead..!)
     static generations: uint = 16;
     fn child_no(x: uint) -> proc() {
-        return || {
+        return proc() {
             if x < generations {
                 let mut t = task();
                 t.unwatched();
@@ -783,7 +783,7 @@ fn test_simple_newsched_spawn() {
     use rt::test::run_in_uv_task;
 
     do run_in_uv_task {
-        spawn(||())
+        spawn(proc()())
     }
 }
 

src/libstd/task/spawn.rs

@@ -180,7 +180,7 @@ pub fn spawn_raw(mut opts: TaskOpts, f: proc()) {
     if opts.notify_chan.is_some() {
         let notify_chan = opts.notify_chan.take_unwrap();
         let notify_chan = Cell::new(notify_chan);
-        let on_exit: proc(UnwindResult) = |task_result| {
+        let on_exit: proc(UnwindResult) = proc(task_result) {
             notify_chan.take().send(task_result)
         };
         task.death.on_exit = Some(on_exit);

src/test/bench/shootout-pfib.rs

@@ -46,7 +46,7 @@ fn pfib(c: &SharedChan<int>, n: int) {
 
     let (p, ch) = stream();
     let ch = SharedChan::new(ch);
-    let _t = task::spawn(|| pfib(&ch, n) );
+    let _t = task::spawn(proc() pfib(&ch, n) );
     p.recv()
 }
 

src/test/bench/task-perf-spawnalot.rs

@@ -33,5 +33,5 @@ fn main() {
     };
     let n = from_str::<uint>(args[1]).unwrap();
     let mut i = 0u;
-    while i < n { task::spawn(|| f(n) ); i += 1u; }
+    while i < n { task::spawn(proc() f(n) ); i += 1u; }
 }

src/test/compile-fail/borrowck-loan-blocks-move-cc.rs

@@ -24,7 +24,7 @@ fn box_imm() {
 
     let v = ~3;
     let _w = &v;
-    task::spawn(|| {
+    task::spawn(proc() {
         info!("v={}", *v);
         //~^ ERROR cannot move
     });

src/test/compile-fail/borrowck-move-by-capture.rs

@@ -3,6 +3,6 @@ pub fn main() {
     // you get two error reports here.
     let bar = ~3;
     let _g = || { //~ ERROR capture of moved value
-        let _h: proc() -> int = || *bar; //~ ERROR capture of moved value
+        let _h: proc() -> int = proc() *bar; //~ ERROR capture of moved value
     };
 }

src/test/compile-fail/borrowck-move-moved-value-into-closure.rs

@@ -5,6 +5,6 @@ fn call_f(f: proc() -> int) -> int {
 fn main() {
     let t = ~3;
 
-    call_f(|| { *t + 1 });
-    call_f(|| { *t + 1 }); //~ ERROR capture of moved value
+    call_f(proc() { *t + 1 });
+    call_f(proc() { *t + 1 }); //~ ERROR capture of moved value
 }

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

@@ -14,7 +14,7 @@ fn foo(_x: @uint) {}
 
 fn main() {
     let x = @3u;
-    let _: proc() = || foo(x); //~ ERROR does not fulfill `Send`
-    let _: proc() = || foo(x); //~ ERROR does not fulfill `Send`
-    let _: proc() = || foo(x); //~ ERROR does not fulfill `Send`
+    let _: proc() = proc() foo(x); //~ ERROR does not fulfill `Send`
+    let _: proc() = proc() foo(x); //~ ERROR does not fulfill `Send`
+    let _: proc() = proc() foo(x); //~ ERROR does not fulfill `Send`
 }

src/test/run-fail/unwind-box-fn-unique.rs

@@ -18,7 +18,7 @@ fn failfn() {
 
 fn main() {
     let y = ~0;
-    let x: @proc() = @(|| {
+    let x: @proc() = @(proc() {
         error!("{:?}", y.clone());
     });
     failfn();

src/test/run-pass/block-arg-call-as.rs

@@ -19,7 +19,7 @@ fn asBlock(f: || -> uint) -> uint {
 }
 
 pub fn main() {
-   let x = asSendfn(|| 22u);
+   let x = asSendfn(proc() 22u);
    assert_eq!(x, 22u);
    let x = asBlock(|| 22u);
    assert_eq!(x, 22u);

src/test/run-pass/borrowck-move-by-capture-ok.rs

 pub fn main() {
     let bar = ~3;
-    let h: proc() -> int = || *bar;
+    let h: proc() -> int = proc() *bar;
     assert_eq!(h(), 3);
 }

src/test/run-pass/cap-clause-move.rs

@@ -13,11 +13,11 @@
 pub fn main() {
     let x = ~3;
     let y = ptr::to_unsafe_ptr(&(*x)) as uint;
-    let snd_move: proc() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint;
+    let snd_move: proc() -> uint = proc() ptr::to_unsafe_ptr(&(*x)) as uint;
     assert_eq!(snd_move(), y);
 
     let x = ~4;
     let y = ptr::to_unsafe_ptr(&(*x)) as uint;
-    let lam_move: proc() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint;
+    let lam_move: proc() -> uint = proc() ptr::to_unsafe_ptr(&(*x)) as uint;
     assert_eq!(lam_move(), y);
 }

src/test/run-pass/child-outlives-parent.rs

@@ -15,5 +15,5 @@
 fn child2(_s: ~str) { }
 
 pub fn main() {
-    let _x = task::spawn(|| child2(~"hi"));
+    let _x = task::spawn(proc() child2(~"hi"));
 }

src/test/run-pass/cleanup-copy-mode.rs

@@ -15,7 +15,7 @@
 fn adder(x: @int, y: @int) -> int { return *x + *y; }
 fn failer() -> @int { fail!(); }
 pub fn main() {
-    assert!(task::try(|| {
+    assert!(task::try(proc() {
         adder(@2, failer()); ()
     }).is_err());
 }

src/test/run-pass/clone-with-exterior.rs

@@ -19,7 +19,7 @@ struct Pair {
 pub fn main() {
     let z = ~Pair { a : 10, b : 12};
 
-    let f: proc() = || {
+    let f: proc() = proc() {
         assert_eq!(z.a, 10);
         assert_eq!(z.b, 12);
     };

src/test/run-pass/comm.rs

@@ -12,7 +12,7 @@
 
 pub fn main() {
     let (p, ch) = stream();
-    let _t = task::spawn(|| child(&ch) );
+    let _t = task::spawn(proc() child(&ch));
     let y = p.recv();
     error!("received");
     error!("{:?}", y);

src/test/run-pass/hashmap-memory.rs

@@ -34,7 +34,7 @@ fn start_mappers(ctrl: SharedChan<ctrl_proto>, inputs: ~[~str]) {
         for i in inputs.iter() {
             let ctrl = ctrl.clone();
             let i = i.clone();
-            task::spawn(|| map_task(ctrl.clone(), i.clone()) );
+            task::spawn(proc() map_task(ctrl.clone(), i.clone()) );
         }
     }
 

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

@@ -21,7 +21,7 @@
 
 fn tester()
 {
-    let loader: rsrc_loader = |_path| {result::Ok(~"more blah")};
+    let loader: rsrc_loader = proc(_path) {result::Ok(~"more blah")};
 
     let path = path::Path::new("blah");
     assert!(loader(&path).is_ok());

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

@@ -14,13 +14,11 @@ enum Msg
 fn foo(name: ~str, samples_chan: Chan<Msg>) {
     do task::spawn
     {
-        let callback: SamplesFn =
-            |buffer|
-            {
-                for i in range(0u, buffer.len()) {
-                    error!("{}: {}", i, buffer[i])
-                }
-            };
+        let callback: SamplesFn = proc(buffer) {
+            for i in range(0u, buffer.len()) {
+                error!("{}: {}", i, buffer[i])
+            }
+        };
         samples_chan.send(GetSamples(name.clone(), callback));
     };
 }

src/test/run-pass/ivec-tag.rs

@@ -8,7 +8,7 @@ fn producer(c: &Chan<~[u8]>) {
 
 pub fn main() {
     let (p, ch) = stream::<~[u8]>();
-    let _prod = task::spawn(|| producer(&ch) );
+    let _prod = task::spawn(proc() producer(&ch) );
 
     let _data: ~[u8] = p.recv();
 }

src/test/run-pass/newlambdas-ret-infer.rs

@@ -11,7 +11,7 @@
 // Test that the lambda kind is inferred correctly as a return
 // expression
 
-fn unique() -> proc() { return || (); }
+fn unique() -> proc() { return proc() (); }
 
 pub fn main() {
 }

src/test/run-pass/newlambdas-ret-infer2.rs

@@ -11,7 +11,7 @@
 // Test that the lambda kind is inferred correctly as a return
 // expression
 
-fn unique() -> proc() { || () }
+fn unique() -> proc() { proc() () }
 
 pub fn main() {
 }

src/test/run-pass/operator-overloading.rs

@@ -69,6 +69,6 @@ pub fn main() {
     assert_eq!(q.y, !(p.y));
 
     // Issue #1733
-    let result: proc(int) = |_|();
+    let result: proc(int) = proc(_)();
     result(p[true]);
 }

src/test/run-pass/sendfn-spawn-with-fn-arg.rs

@@ -19,12 +19,12 @@ fn test05_start(f: proc(int)) {
 
 fn test05() {
     let three = ~3;
-    let fn_to_send: proc(int) = |n| {
+    let fn_to_send: proc(int) = proc(n) {
         error!("{}", *three + n); // will copy x into the closure
         assert_eq!(*three, 3);
     };
     let fn_to_send = Cell::new(fn_to_send);
-    task::spawn(|| {
+    task::spawn(proc() {
         test05_start(fn_to_send.take());
     });
 }

src/test/run-pass/spawn-fn.rs

@@ -16,9 +16,9 @@ fn x(s: ~str, n: int) {
 }
 
 pub fn main() {
-    task::spawn(|| x(~"hello from first spawned fn", 65) );
-    task::spawn(|| x(~"hello from second spawned fn", 66) );
-    task::spawn(|| x(~"hello from third spawned fn", 67) );
+    task::spawn(proc() x(~"hello from first spawned fn", 65) );
+    task::spawn(proc() x(~"hello from second spawned fn", 66) );
+    task::spawn(proc() x(~"hello from third spawned fn", 67) );
     let mut i: int = 30;
     while i > 0 { i = i - 1; info!("parent sleeping"); task::deschedule(); }
 }

src/test/run-pass/spawn-types.rs

@@ -24,5 +24,5 @@ fn iotask(_cx: &ctx, ip: ~str) {
 
 pub fn main() {
     let (_p, ch) = stream::<int>();
-    task::spawn(|| iotask(&ch, ~"localhost") );
+    task::spawn(proc() iotask(&ch, ~"localhost") );
 }

src/test/run-pass/spawn.rs

@@ -13,7 +13,7 @@
 use std::task;
 
 pub fn main() {
-    task::spawn(|| child(10) );
+    task::spawn(proc() child(10) );
 }
 
 fn child(i: int) { error!("{}", i); assert!((i == 10)); }

src/test/run-pass/spawn2.rs

@@ -10,7 +10,7 @@
 
 use std::task;
 
-pub fn main() { task::spawn(|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); }
+pub fn main() { task::spawn(proc() child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); }
 
 fn child(args: (int, int, int, int, int, int, int, int, int)) {
     let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;

src/test/run-pass/spawning-with-debug.rs

@@ -18,5 +18,5 @@
 fn main() {
     let mut t = task::task();
     t.sched_mode(task::SingleThreaded);
-    t.spawn(|| ());
+    t.spawn(proc() ());
 }

src/test/run-pass/swap-overlapping.rs

@@ -18,7 +18,7 @@ pub fn main() {
             name: DynTestName(~"test"),
             should_fail: false
         },
-        testfn: DynTestFn(|| ()),
+        testfn: DynTestFn(proc() ()),
     };
     do_swap(&mut test);
 }

src/test/run-pass/task-comm-0.rs

@@ -29,7 +29,7 @@ fn test05_start(ch : &Chan<int>) {
 
 fn test05() {
     let (po, ch) = comm::stream();
-    task::spawn(|| test05_start(&ch) );
+    task::spawn(proc() test05_start(&ch) );
     let mut value: int = po.recv();
     error!("{}", value);
     value = po.recv();

src/test/run-pass/task-comm-1.rs

@@ -15,6 +15,6 @@
 fn start() { info!("Started / Finished task."); }
 
 fn test00() {
-    task::try(|| start() );
+    task::try(proc() start() );
     info!("Completing.");
 }

src/test/run-pass/task-comm-10.rs

@@ -31,7 +31,7 @@ fn start(c: &comm::Chan<comm::Chan<~str>>) {
 
 pub fn main() {
     let (p, ch) = comm::stream();
-    let _child = task::spawn(|| start(&ch) );
+    let _child = task::spawn(proc() start(&ch) );
 
     let c = p.recv();
     c.send(~"A");

src/test/run-pass/task-comm-11.rs

@@ -22,6 +22,6 @@ fn start(c: &comm::Chan<comm::Chan<int>>) {
 
 pub fn main() {
     let (p, ch) = comm::stream();
-    let _child = task::spawn(|| start(&ch) );
+    let _child = task::spawn(proc() start(&ch) );
     let _c = p.recv();
 }

src/test/run-pass/task-comm-13.rs

@@ -23,6 +23,6 @@ fn start(c: &comm::Chan<int>, start: int, number_of_messages: int) {
 pub fn main() {
     info!("Check that we don't deadlock.");
     let (_p, ch) = comm::stream();
-    task::try(|| start(&ch, 0, 10) );
+    task::try(proc() start(&ch, 0, 10) );
     info!("Joined task");
 }

src/test/run-pass/task-comm-14.rs

@@ -22,7 +22,7 @@ pub fn main() {
     while (i > 0) {
         info!("{}", i);
         let ch = ch.clone();
-        task::spawn({let i = i; || child(i, &ch)});
+        task::spawn({let i = i; proc() child(i, &ch)});
         i = i - 1;
     }
 

src/test/run-pass/task-comm-15.rs

@@ -29,6 +29,6 @@ pub fn main() {
     // the child's point of view the receiver may die. We should
     // drop messages on the floor in this case, and not crash!
     let (p, ch) = comm::stream();
-    task::spawn(|| start(&ch, 10));
+    task::spawn(proc() start(&ch, 10));
     p.recv();
 }

src/test/run-pass/task-comm-17.rs

@@ -20,5 +20,5 @@ fn f() {
 }
 
 pub fn main() {
-    task::spawn(|| f() );
+    task::spawn(proc() f() );
 }

src/test/run-pass/task-comm-3.rs

@@ -48,7 +48,7 @@ fn test00() {
         results.push(builder.future_result());
         builder.spawn({
             let i = i;
-            || test00_start(&ch, i, number_of_messages)
+            proc() test00_start(&ch, i, number_of_messages)
         });
         i = i + 1;
     }

src/test/run-pass/task-life-0.rs

@@ -13,7 +13,7 @@
 use std::task;
 
 pub fn main() {
-    task::spawn(|| child(~"Hello") );
+    task::spawn(proc() child(~"Hello") );
 }
 
 fn child(_s: ~str) {

src/test/run-pass/task-spawn-move-and-copy.rs

@@ -17,7 +17,7 @@ pub fn main() {
     let x = ~1;
     let x_in_parent = ptr::to_unsafe_ptr(&(*x)) as uint;
 
-    task::spawn(|| {
+    task::spawn(proc() {
         let x_in_child = ptr::to_unsafe_ptr(&(*x)) as uint;
         ch.send(x_in_child);
     });

src/test/run-pass/tempfile.rs

@@ -40,7 +40,7 @@ fn test_tempdir() {
 
 fn test_rm_tempdir() {
     let (rd, wr) = stream();
-    let f: proc() = || {
+    let f: proc() = proc() {
         let tmp = TempDir::new("test_rm_tempdir").unwrap();
         wr.send(tmp.path().clone());
         fail!("fail to unwind past `tmp`");
@@ -52,7 +52,7 @@ fn test_rm_tempdir() {
     let tmp = TempDir::new("test_rm_tempdir").unwrap();
     let path = tmp.path().clone();
     let cell = Cell::new(tmp);
-    let f: proc() = || {
+    let f: proc() = proc() {
         let _tmp = cell.take();
         fail!("fail to unwind past `tmp`");
     };
@@ -61,7 +61,7 @@ fn test_rm_tempdir() {
 
     let path;
     {
-        let f: proc() -> TempDir = || {
+        let f: proc() -> TempDir = proc() {
             TempDir::new("test_rm_tempdir").unwrap()
         };
         let tmp = task::try(f).expect("test_rm_tmdir");

src/test/run-pass/terminate-in-initializer.rs

@@ -25,13 +25,13 @@
 
 fn test_fail() {
     fn f() { let _x: @int = fail!(); }
-    task::try(|| f() );
+    task::try(proc() f() );
 }
 
 fn test_fail_indirect() {
     fn f() -> ! { fail!(); }
     fn g() { let _x: @int = f(); }
-    task::try(|| g() );
+    task::try(proc() g() );
 }
 
 pub fn main() {

src/test/run-pass/threads.rs

@@ -14,7 +14,7 @@
 
 pub fn main() {
     let mut i = 10;
-    while i > 0 { task::spawn({let i = i; || child(i)}); i = i - 1; }
+    while i > 0 { task::spawn({let i = i; proc() child(i)}); i = i - 1; }
     info!("main thread exiting");
 }
 

src/test/run-pass/uniq-cc-generic.rs

@@ -23,7 +23,7 @@ struct Pointy {
 }
 
 fn make_uniq_closure<A:Send>(a: A) -> proc() -> uint {
-    let result: proc() -> uint = || ptr::to_unsafe_ptr(&a) as uint;
+    let result: proc() -> uint = proc() ptr::to_unsafe_ptr(&a) as uint;
     result
 }
 

src/test/run-pass/uniq-cc.rs

@@ -25,7 +25,7 @@ fn empty_pointy() -> @mut Pointy {
     return @mut Pointy {
         a : none,
         c : ~22,
-        d : || {},
+        d : proc() {},
     }
 }
 

src/test/run-pass/unique-send-2.rs

@@ -22,7 +22,7 @@ pub fn main() {
     let mut expected = 0u;
     for i in range(0u, n) {
         let ch = ch.clone();
-        task::spawn(|| child(&ch, i) );
+        task::spawn(proc() child(&ch, i) );
         expected += i;
     }
 

src/test/run-pass/unwind-resource.rs

@@ -42,7 +42,7 @@ fn f(c: SharedChan<bool>) {
 pub fn main() {
     let (p, c) = stream();
     let c = SharedChan::new(c);
-    task::spawn(|| f(c.clone()) );
+    task::spawn(proc() f(c.clone()));
     error!("hiiiiiiiii");
     assert!(p.recv());
 }