Remove temporary fn# syntax

Author: brson

src/comp/syntax/parse/parser.rs

@@ -2135,20 +2135,12 @@ fn parse_auth(p: parser) -> ast::_auth {
     } else { unexpected(p, p.peek()); }
 }
 
-fn parse_fn_item_proto(p: parser) -> ast::proto {
-    if p.peek() == token::POUND {
-        p.bump();
-        ast::proto_bare
-    } else {
-        ast::proto_bare
-    }
+fn parse_fn_item_proto(_p: parser) -> ast::proto {
+    ast::proto_bare
 }
 
 fn parse_fn_ty_proto(p: parser) -> ast::proto {
-    if p.peek() == token::POUND {
-        p.bump();
-        ast::proto_bare
-    } else if p.peek() == token::AT {
+    if p.peek() == token::AT {
         p.bump();
         ast::proto_shared(ast::sugar_normal)
     } else {
@@ -2157,10 +2149,7 @@ fn parse_fn_ty_proto(p: parser) -> ast::proto {
 }
 
 fn parse_fn_anon_proto(p: parser) -> ast::proto {
-    if p.peek() == token::POUND {
-        p.bump();
-        ast::proto_bare
-    } else if p.peek() == token::AT {
+    if p.peek() == token::AT {
         p.bump();
         ast::proto_shared(ast::sugar_normal)
     } else {

src/compiletest/compiletest.rs

@@ -195,7 +195,7 @@ fn closure_to_task(cx: cx, configport: port<[u8]>, testfn: fn@()) ->
         (cx.config, cx.procsrv.chan, testfile), run_test_task);
 }
 
-fn# run_test_task(args: (common::config, procsrv::reqchan, [u8])) {
+fn run_test_task(args: (common::config, procsrv::reqchan, [u8])) {
 
     let (config, procsrv_chan, testfile) = args;
 

src/compiletest/procsrv.rs

@@ -39,7 +39,7 @@ fn mk() -> handle {
     let setupport = port();
     let task = task::spawn_joinable(
         chan(setupport),
-        fn# (setupchan: chan<chan<request>>) {
+        fn (setupchan: chan<chan<request>>) {
             let reqport = port();
             let reqchan = chan(reqport);
             send(setupchan, reqchan);

src/lib/aio.rs

@@ -49,7 +49,7 @@ fn ip_to_sbuf(ip: net::ip_addr) -> *u8 unsafe {
     vec::to_ptr(str::bytes(net::format_addr(ip)))
 }
 
-fn# connect_task(args: (net::ip_addr, int, chan<socket_event>)) {
+fn connect_task(args: (net::ip_addr, int, chan<socket_event>)) {
     let (ip, portnum, evt) = args;
     let connecter = port();
     rustrt::aio_connect(ip_to_sbuf(ip), portnum, chan(connecter));
@@ -84,7 +84,7 @@ fn new_client(client: client, evt: chan<socket_event>) {
     log "close message sent";
 }
 
-fn# accept_task(args: (client, chan<server_event>)) {
+fn accept_task(args: (client, chan<server_event>)) {
     let (client, events) = args;
     log "accept task was spawned";
     let p = port();
@@ -94,7 +94,7 @@ fn# accept_task(args: (client, chan<server_event>)) {
     log "done accepting";
 }
 
-fn# server_task(args: (net::ip_addr, int, chan<server_event>,
+fn server_task(args: (net::ip_addr, int, chan<server_event>,
                        chan<server>)) {
     let (ip, portnum, events, server) = args;
     let accepter = port();
@@ -111,7 +111,7 @@ fn# server_task(args: (net::ip_addr, int, chan<server_event>,
     }
 }
 
-fn# request_task(c: chan<ctx>) {
+fn request_task(c: chan<ctx>) {
     // Create a port to accept IO requests on
     let p = port();
     // Hand of its channel to our spawner
@@ -150,7 +150,7 @@ fn# request_task(c: chan<ctx>) {
     }
 }
 
-fn# iotask(c: chan<ctx>) {
+fn iotask(c: chan<ctx>) {
     log "io task spawned";
     // Initialize before accepting requests
     rustrt::aio_init();

src/lib/task.rs

@@ -93,16 +93,16 @@ fn unpin() { rustrt::unpin_task(); }
 
 fn set_min_stack(stack_size: uint) { rustrt::set_min_stack(stack_size); }
 
-fn spawn<~T>(-data: T, f: fn#(T)) -> task {
+fn spawn<~T>(-data: T, f: fn(T)) -> task {
     spawn_inner2(data, f, none)
 }
 
-fn spawn_notify<~T>(-data: T, f: fn#(T),
+fn spawn_notify<~T>(-data: T, f: fn(T),
                          notify: comm::chan<task_notification>) -> task {
     spawn_inner2(data, f, some(notify))
 }
 
-fn spawn_joinable<~T>(-data: T, f: fn#(T)) -> joinable_task {
+fn spawn_joinable<~T>(-data: T, f: fn(T)) -> joinable_task {
     let p = comm::port::<task_notification>();
     let id = spawn_notify(data, f, comm::chan::<task_notification>(p));
     ret (id, p);
@@ -118,11 +118,11 @@ fn spawn_joinable<~T>(-data: T, f: fn#(T)) -> joinable_task {
 //
 // After the transition this should all be rewritten.
 
-fn spawn_inner2<~T>(-data: T, f: fn#(T),
+fn spawn_inner2<~T>(-data: T, f: fn(T),
                     notify: option<comm::chan<task_notification>>)
     -> task_id {
 
-    fn wrapper<~T>(-data: *u8, f: fn#(T)) {
+    fn wrapper<~T>(-data: *u8, f: fn(T)) {
         let data: ~T = unsafe::reinterpret_cast(data);
         f(*data);
     }

src/lib/test.rs

@@ -43,7 +43,7 @@ type test_name = str;
 // to support isolation of tests into tasks.
 type test_fn<@T> = T;
 
-type default_test_fn = test_fn<fn#()>;
+type default_test_fn = test_fn<fn()>;
 
 // The definition of a single test. A test runner will run a list of
 // these.
@@ -321,7 +321,7 @@ fn run_test<@T>(test: test_desc<T>,
 // We need to run our tests in another task in order to trap test failures.
 // This function only works with functions that don't contain closures.
 fn default_test_to_task(&&f: default_test_fn) -> joinable {
-    fn# run_task(f: default_test_fn) {
+    fn run_task(f: default_test_fn) {
         configure_test_task();
         f();
     }

src/test/bench/shootout-pfib.rs

@@ -27,7 +27,7 @@ import std::comm::send;
 import std::comm::recv;
 
 fn fib(n: int) -> int {
-    fn# pfib(args: (chan<int>, int)) {
+    fn pfib(args: (chan<int>, int)) {
         let (c, n) = args;
         if n == 0 {
             send(c, 0);
@@ -62,7 +62,7 @@ fn parse_opts(argv: [str]) -> config {
     }
 }
 
-fn# stress_task(&&id: int) {
+fn stress_task(&&id: int) {
     let i = 0;
     while true {
         let n = 15;

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

@@ -4,15 +4,15 @@ import std::task;
 import std::uint;
 import std::str;
 
-fn# f(&&n: uint) {
+fn f(&&n: uint) {
     let i = 0u;
     while i < n {
         task::join(task::spawn_joinable((), g));
         i += 1u;
     }
 }
 
-fn# g(&&_i: ()) { }
+fn g(&&_i: ()) { }
 
 fn main(args: [str]) {
     let n =

src/test/bench/task-perf-vector-party.rs

@@ -9,7 +9,7 @@ import std::uint;
 import std::str;
 import std::task;
 
-fn# f(&&n: uint) {
+fn f(&&n: uint) {
     for each i in uint::range(0u, n) {
         let v: [u8] = [];
         vec::reserve(v, 1000u);

src/test/bench/task-perf-word-count.rs

@@ -75,7 +75,7 @@ mod map_reduce {
         ret tasks;
     }
 
-    fn# map_task(args: (chan<ctrl_proto>, str)) {
+    fn map_task(args: (chan<ctrl_proto>, str)) {
         let (ctrl, input) = args;
         // log_err "map_task " + input;
         let intermediates = map::new_str_hash();
@@ -108,7 +108,7 @@ mod map_reduce {
         send(ctrl, mapper_done);
     }
 
-    fn# reduce_task(args: (str, chan<chan<reduce_proto>>)) {
+    fn reduce_task(args: (str, chan<chan<reduce_proto>>)) {
         let (key, out) = args;
         let p = port();