diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 2a980d3a07e7..dbf603166681 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/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 {
diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 7a45cc40bae0..aa77febd2288 100644
--- a/src/compiletest/compiletest.rs
+++ b/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;
 
diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs
index f3c7bc9406c3..5caf9f7d57a1 100644
--- a/src/compiletest/procsrv.rs
+++ b/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);
diff --git a/src/lib/aio.rs b/src/lib/aio.rs
index c06d1fa3db14..162090af0d76 100644
--- a/src/lib/aio.rs
+++ b/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();
diff --git a/src/lib/task.rs b/src/lib/task.rs
index 903e4b34a816..ac56a1f6034a 100644
--- a/src/lib/task.rs
+++ b/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);
     }
diff --git a/src/lib/test.rs b/src/lib/test.rs
index 0df3667ea4a4..9ef9391933dc 100644
--- a/src/lib/test.rs
+++ b/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();
     }
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 292db247e6f2..f3bede8320da 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/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;
diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index ff8c0cb05f79..8e12bc7edee6 100644
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -4,7 +4,7 @@ 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));
@@ -12,7 +12,7 @@ fn# f(&&n: uint) {
     }
 }
 
-fn# g(&&_i: ()) { }
+fn g(&&_i: ()) { }
 
 fn main(args: [str]) {
     let n =
diff --git a/src/test/bench/task-perf-vector-party.rs b/src/test/bench/task-perf-vector-party.rs
index c8c359b11ccd..1c07618284d3 100644
--- a/src/test/bench/task-perf-vector-party.rs
+++ b/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);
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index f7c49d6432fb..f988c931deef 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/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();
 
diff --git a/src/test/compile-fail/fn-bare-bind.rs b/src/test/compile-fail/fn-bare-bind.rs
index 05ead1b28369..1635a91c14f7 100644
--- a/src/test/compile-fail/fn-bare-bind.rs
+++ b/src/test/compile-fail/fn-bare-bind.rs
@@ -1,9 +1,9 @@
 // error-pattern:mismatched types: expected fn() but found fn@()
 
-fn# f() {
+fn f() {
 }
 
 fn main() {
     // Can't produce a bare function by binding
-    let g: fn#() = bind f();
+    let g: fn() = bind f();
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/fn-bare-generic-instantiate1.rs b/src/test/compile-fail/fn-bare-generic-instantiate1.rs
index 094bec272091..6d610288c38b 100644
--- a/src/test/compile-fail/fn-bare-generic-instantiate1.rs
+++ b/src/test/compile-fail/fn-bare-generic-instantiate1.rs
@@ -2,9 +2,9 @@
 // Issue #1038
 
 fn main() {
-    fn# foo<T>() { }
+    fn foo<T>() { }
 
     // This wants to build a closure over type int,
     // but there's no way to do that while still being a bare function
-    let f: fn#() = foo::<int>;
+    let f: fn() = foo::<int>;
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/fn-bare-generic-instantiate2.rs b/src/test/compile-fail/fn-bare-generic-instantiate2.rs
index 2b82ec57e60b..e9e21af14808 100644
--- a/src/test/compile-fail/fn-bare-generic-instantiate2.rs
+++ b/src/test/compile-fail/fn-bare-generic-instantiate2.rs
@@ -2,12 +2,12 @@
 // Issue #1038
 
 fn main() {
-    fn# foo<T>(i: T) { }
+    fn foo<T>(i: T) { }
 
     // This wants to build a closure over type int,
     // but there's no way to do that while still being a bare function
     f(foo);
 }
 
-fn f(i: fn#(&&int)) {
+fn f(i: fn(&&int)) {
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/spawn-non-nil-fn.rs b/src/test/compile-fail/spawn-non-nil-fn.rs
index 5e467d1e03f7..ef7cf1d8cc0e 100644
--- a/src/test/compile-fail/spawn-non-nil-fn.rs
+++ b/src/test/compile-fail/spawn-non-nil-fn.rs
@@ -3,6 +3,6 @@
 use std;
 import std::task;
 
-fn# f(&&x: int) -> int { ret x; }
+fn f(&&x: int) -> int { ret x; }
 
 fn main() { task::spawn(10, f); }
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index 0b6bea132d28..d11dc4147ef7 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -6,7 +6,7 @@ import std::task;
 import std::comm::port;
 import std::comm::recv;
 
-fn# child(&&_i: ()) { assert (1 == 2); }
+fn child(&&_i: ()) { assert (1 == 2); }
 
 fn main() {
     let p = port::<int>();
diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs
index 61d1827f055e..1bdea315151f 100644
--- a/src/test/run-fail/linked-failure2.rs
+++ b/src/test/run-fail/linked-failure2.rs
@@ -7,7 +7,7 @@ import std::comm::chan;
 import std::comm::port;
 import std::comm::recv;
 
-fn# child(&&_i: ()) { fail; }
+fn child(&&_i: ()) { fail; }
 
 fn main() {
     let p = port::<int>();
diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs
index 057095a3a4b5..608356974089 100644
--- a/src/test/run-fail/linked-failure3.rs
+++ b/src/test/run-fail/linked-failure3.rs
@@ -6,9 +6,9 @@ import std::task;
 import std::comm::port;
 import std::comm::recv;
 
-fn# grandchild(&&_i: ()) { fail; }
+fn grandchild(&&_i: ()) { fail; }
 
-fn# child(&&_i: ()) {
+fn child(&&_i: ()) {
     let p = port::<int>();
     task::spawn((), grandchild);
     let x = recv(p);
diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs
index 98778a9f9d7e..c79fa33cf731 100644
--- a/src/test/run-fail/task-comm-recv-block.rs
+++ b/src/test/run-fail/task-comm-recv-block.rs
@@ -4,7 +4,7 @@ use std;
 import std::task;
 import std::comm;
 
-fn# goodfail(&&_i: ()) {
+fn goodfail(&&_i: ()) {
     task::yield();
     fail "goodfail";
 }
diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs
index dbfd515244ac..9705e902d6ac 100644
--- a/src/test/run-pass/basic-1.rs
+++ b/src/test/run-pass/basic-1.rs
@@ -7,7 +7,7 @@ import std::comm::send;
 import std::comm::recv;
 import std::task;
 
-fn# a(c: chan<int>) { send(c, 10); }
+fn a(c: chan<int>) { send(c, 10); }
 
 fn main() {
     let p = port();
diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs
index 5a7dc86f64fd..228c4f96dbb6 100644
--- a/src/test/run-pass/basic-2.rs
+++ b/src/test/run-pass/basic-2.rs
@@ -7,7 +7,7 @@ import std::comm::chan;
 import std::comm::recv;
 import std::task;
 
-fn# a(c: chan<int>) { log "task a0"; log "task a1"; send(c, 10); }
+fn a(c: chan<int>) { log "task a0"; log "task a1"; send(c, 10); }
 
 fn main() {
     let p = comm::port();
@@ -19,7 +19,7 @@ fn main() {
     log "Finished.";
 }
 
-fn# b(c: chan<int>) {
+fn b(c: chan<int>) {
     log "task b0";
     log "task b1";
     log "task b2";
diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs
index 381ebba11282..2547b48f8a5b 100644
--- a/src/test/run-pass/basic.rs
+++ b/src/test/run-pass/basic.rs
@@ -7,7 +7,7 @@ import std::comm::chan;
 import std::comm::recv;
 import std::task;
 
-fn# a(c: chan<int>) {
+fn a(c: chan<int>) {
     if true {
         log "task a";
         log "task a";
@@ -37,7 +37,7 @@ fn main() {
     log "children finished, root finishing";
 }
 
-fn# b(c: chan<int>) {
+fn b(c: chan<int>) {
     if true {
         log "task b";
         log "task b";
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index ee3476c94774..0a76fbe62b9c 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -87,7 +87,7 @@ fn test_ptr() {
 }
 
 fn test_task() {
-    fn# f(&&_i: ()) { }
+    fn f(&&_i: ()) { }
     let f1 = f, f2 = f;
     let t1 = task::spawn((), f1);
     let t2 = task::spawn((), f2);
diff --git a/src/test/run-pass/chan-leak.rs b/src/test/run-pass/chan-leak.rs
index 5ea0cda7783e..b62309862720 100644
--- a/src/test/run-pass/chan-leak.rs
+++ b/src/test/run-pass/chan-leak.rs
@@ -12,7 +12,7 @@ tag request { quit; close(chan<bool>); }
 
 type ctx = chan<request>;
 
-fn# request_task(c: chan<ctx>) {
+fn request_task(c: chan<ctx>) {
     let p = port();
     send(c, chan(p));
     let req: request;
diff --git a/src/test/run-pass/child-outlives-parent.rs b/src/test/run-pass/child-outlives-parent.rs
index a2f7a59f9179..95c70bc7a7b2 100644
--- a/src/test/run-pass/child-outlives-parent.rs
+++ b/src/test/run-pass/child-outlives-parent.rs
@@ -3,6 +3,6 @@
 use std;
 import std::task;
 
-fn# child2(&&s: str) { }
+fn child2(&&s: str) { }
 
 fn main() { let x = task::spawn("hi", child2); }
diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index c8a911596cfa..2de0d0e4c90f 100644
--- a/src/test/run-pass/comm.rs
+++ b/src/test/run-pass/comm.rs
@@ -16,7 +16,7 @@ fn main() {
     assert (y == 10);
 }
 
-fn# child(c: chan<int>) {
+fn child(c: chan<int>) {
     log_err "sending";
     send(c, 10);
     log_err "value sent"
diff --git a/src/test/run-pass/fn-bare-anon-2.rs b/src/test/run-pass/fn-bare-anon-2.rs
index 0ea38070b8e5..f83e145ac38c 100644
--- a/src/test/run-pass/fn-bare-anon-2.rs
+++ b/src/test/run-pass/fn-bare-anon-2.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let f: fn#() = fn# () {
+    let f: fn() = fn () {
         log "This is a bare function"
     };
     let g;
diff --git a/src/test/run-pass/fn-bare-anon.rs b/src/test/run-pass/fn-bare-anon.rs
index 08fb613e0ad6..8c56f937aee5 100644
--- a/src/test/run-pass/fn-bare-anon.rs
+++ b/src/test/run-pass/fn-bare-anon.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let f: fn#() = fn# () {
+    let f: fn() = fn () {
         log "This is a bare function"
     };
     f();
diff --git a/src/test/run-pass/fn-bare-assign.rs b/src/test/run-pass/fn-bare-assign.rs
index d3d81d1bb19a..ce821cbadf4c 100644
--- a/src/test/run-pass/fn-bare-assign.rs
+++ b/src/test/run-pass/fn-bare-assign.rs
@@ -1,9 +1,9 @@
-fn# f(i: int, &called: bool) {
+fn f(i: int, &called: bool) {
     assert i == 10;
     called = true;
 }
 
-fn# g(f: fn#(int, &bool), &called: bool) {
+fn g(f: fn(int, &bool), &called: bool) {
     f(10, called);
 }
 
diff --git a/src/test/run-pass/fn-bare-bind-generic.rs b/src/test/run-pass/fn-bare-bind-generic.rs
index 3e5935427f09..58b28df63ae8 100644
--- a/src/test/run-pass/fn-bare-bind-generic.rs
+++ b/src/test/run-pass/fn-bare-bind-generic.rs
@@ -1,4 +1,4 @@
-fn# f<T>(i: T, j: T, k: T) {
+fn f<T>(i: T, j: T, k: T) {
     assert i == j;
     assert j != k;
 }
diff --git a/src/test/run-pass/fn-bare-bind.rs b/src/test/run-pass/fn-bare-bind.rs
index ec6747cd2553..064e6430f8ad 100644
--- a/src/test/run-pass/fn-bare-bind.rs
+++ b/src/test/run-pass/fn-bare-bind.rs
@@ -1,4 +1,4 @@
-fn# f(i: int) {
+fn f(i: int) {
     assert i == 10;
 }
 
diff --git a/src/test/run-pass/fn-bare-coerce-to-block.rs b/src/test/run-pass/fn-bare-coerce-to-block.rs
index f861cdca4053..9da242f572f4 100644
--- a/src/test/run-pass/fn-bare-coerce-to-block.rs
+++ b/src/test/run-pass/fn-bare-coerce-to-block.rs
@@ -1,4 +1,4 @@
-fn# bare() {}
+fn bare() {}
 
 fn likes_block(f: block()) { f() }
 
diff --git a/src/test/run-pass/fn-bare-coerce-to-shared.rs b/src/test/run-pass/fn-bare-coerce-to-shared.rs
index be375bffb4cc..7e0cb1551b28 100644
--- a/src/test/run-pass/fn-bare-coerce-to-shared.rs
+++ b/src/test/run-pass/fn-bare-coerce-to-shared.rs
@@ -1,4 +1,4 @@
-fn# bare() {}
+fn bare() {}
 
 fn likes_shared(f: fn@()) { f() }
 
diff --git a/src/test/run-pass/fn-bare-item.rs b/src/test/run-pass/fn-bare-item.rs
index a5cdc2e82abb..24a4a48eea62 100644
--- a/src/test/run-pass/fn-bare-item.rs
+++ b/src/test/run-pass/fn-bare-item.rs
@@ -1,4 +1,4 @@
-fn# f() {
+fn f() {
     log "This is a bare function";
 }
 
diff --git a/src/test/run-pass/fn-bare-size.rs b/src/test/run-pass/fn-bare-size.rs
index 2a70ff553736..d575758fd62f 100644
--- a/src/test/run-pass/fn-bare-size.rs
+++ b/src/test/run-pass/fn-bare-size.rs
@@ -4,6 +4,6 @@ use std;
 
 fn main() {
     // Bare functions should just be a pointer
-    assert std::sys::rustrt::size_of::<fn#()>() ==
+    assert std::sys::rustrt::size_of::<fn()>() ==
         std::sys::rustrt::size_of::<int>();
 }
\ No newline at end of file
diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs
index f40459c0f44a..f007d9471e24 100644
--- a/src/test/run-pass/fn-bare-spawn.rs
+++ b/src/test/run-pass/fn-bare-spawn.rs
@@ -1,16 +1,16 @@
 // This is what the signature to spawn should look like with bare functions
 
-fn spawn<~T>(val: T, f: fn#(T)) {
+fn spawn<~T>(val: T, f: fn(T)) {
     f(val);
 }
 
-fn# f(&&i: int) {
+fn f(&&i: int) {
     assert i == 100;
 }
 
 fn main() {
     spawn(100, f);
-    spawn(100, fn#(&&i: int) {
+    spawn(100, fn(&&i: int) {
         assert i == 100;
     });
 }
\ No newline at end of file
diff --git a/src/test/run-pass/fn-coerce-field.rs b/src/test/run-pass/fn-coerce-field.rs
index 759ab37585df..08a58046c33b 100644
--- a/src/test/run-pass/fn-coerce-field.rs
+++ b/src/test/run-pass/fn-coerce-field.rs
@@ -3,5 +3,5 @@ type r = {
 };
 
 fn main() {
-    let i: r = {field: fn#() { }};
+    let i: r = {field: fn() { }};
 }
\ No newline at end of file
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 9f4c4bb17d28..cb43371b3c68 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -36,7 +36,7 @@ mod map_reduce {
         for i: str in inputs { task::spawn((ctrl, i), map_task); }
     }
 
-    fn# map_task(&&args: (chan<ctrl_proto>, str)) {
+    fn map_task(&&args: (chan<ctrl_proto>, str)) {
         let (ctrl, input) = args;
 
         let intermediates = map::new_str_hash();
diff --git a/src/test/run-pass/issue-506.rs b/src/test/run-pass/issue-506.rs
index be73f314d80e..a1df60b4245a 100644
--- a/src/test/run-pass/issue-506.rs
+++ b/src/test/run-pass/issue-506.rs
@@ -9,6 +9,6 @@ native "rust" mod rustrt {
     fn task_yield();
 }
 
-fn# yield_wrap(&&_i: ()) unsafe { rustrt::task_yield(); }
+fn yield_wrap(&&_i: ()) unsafe { rustrt::task_yield(); }
 
 fn main() { task::spawn((), yield_wrap); }
diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs
index 89744707fbc9..7f405141a7bf 100644
--- a/src/test/run-pass/issue-507.rs
+++ b/src/test/run-pass/issue-507.rs
@@ -15,9 +15,9 @@ import std::comm::send;
 import std::comm::port;
 import std::comm::recv;
 
-fn# grandchild(c: chan<int>) { send(c, 42); }
+fn grandchild(c: chan<int>) { send(c, 42); }
 
-fn# child(c: chan<int>) {
+fn child(c: chan<int>) {
     let _grandchild = task::spawn_joinable(c, grandchild);
     join(_grandchild);
 }
diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index 76989f47c6f6..4827c428aa15 100644
--- a/src/test/run-pass/issue-687.rs
+++ b/src/test/run-pass/issue-687.rs
@@ -9,13 +9,13 @@ import std::comm::send;
 
 tag msg { closed; received([u8]); }
 
-fn# producer(c: chan<[u8]>) {
+fn producer(c: chan<[u8]>) {
     send(c, [1u8, 2u8, 3u8, 4u8]);
     let empty: [u8] = [];
     send(c, empty);
 }
 
-fn# packager(&&args: (chan<chan<[u8]>>, chan<msg>)) {
+fn packager(&&args: (chan<chan<[u8]>>, chan<msg>)) {
     let (cb, msg) = args;
     let p: port<[u8]> = port();
     send(cb, chan(p));
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index 6b61def87f6c..09bb40295eaf 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -7,7 +7,7 @@ import std::comm::port;
 import std::comm::send;
 import std::comm::recv;
 
-fn# producer(c: chan<[u8]>) {
+fn producer(c: chan<[u8]>) {
     send(c,
          [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8,
           13u8]);
diff --git a/src/test/run-pass/join.rs b/src/test/run-pass/join.rs
index 323abbce931c..bbbbcb8045b7 100644
--- a/src/test/run-pass/join.rs
+++ b/src/test/run-pass/join.rs
@@ -12,4 +12,4 @@ fn main() {
     log_err "3";
 }
 
-fn# child(&&_i: ()) { log_err "2"; }
+fn child(&&_i: ()) { log_err "2"; }
diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs
index 93eb368febb0..3102a66a1921 100644
--- a/src/test/run-pass/lazychan.rs
+++ b/src/test/run-pass/lazychan.rs
@@ -21,4 +21,4 @@ fn main() {
     assert (y == 10);
 }
 
-fn# child(c: chan<int>) { send(c, 10); }
+fn child(c: chan<int>) { send(c, 10); }
diff --git a/src/test/run-pass/linked-failure.rs b/src/test/run-pass/linked-failure.rs
index 1bee29271b90..054218c28375 100644
--- a/src/test/run-pass/linked-failure.rs
+++ b/src/test/run-pass/linked-failure.rs
@@ -5,9 +5,9 @@ import std::task;
 import std::comm::port;
 import std::comm::recv;
 
-fn# child(&&_i: ()) { assert (1 == 2); }
+fn child(&&_i: ()) { assert (1 == 2); }
 
-fn# parent(&&_i: ()) {
+fn parent(&&_i: ()) {
     // Since this task isn't supervised it won't bring down the whole
     // process
     task::unsupervise();
diff --git a/src/test/run-pass/lots-a-fail.rs b/src/test/run-pass/lots-a-fail.rs
index ded0a0268ad5..f92943161ece 100644
--- a/src/test/run-pass/lots-a-fail.rs
+++ b/src/test/run-pass/lots-a-fail.rs
@@ -4,11 +4,11 @@ import std::task;
 import std::comm;
 import std::uint;
 
-fn# die(&&_i: ()) {
+fn die(&&_i: ()) {
     fail;
 }
 
-fn# iloop(&&_i: ()) {
+fn iloop(&&_i: ()) {
     task::unsupervise();
     task::spawn((), die);
 }
diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs
index 4d4607b0a86f..f344451e662e 100644
--- a/src/test/run-pass/many.rs
+++ b/src/test/run-pass/many.rs
@@ -4,7 +4,7 @@ use std;
 import std::task;
 import std::comm;
 
-fn# sub(&&args: (comm::chan<int>, int)) {
+fn sub(&&args: (comm::chan<int>, int)) {
     let (parent, id) = args;
     if id == 0 {
         comm::send(parent, 0);
diff --git a/src/test/run-pass/send-iloop.rs b/src/test/run-pass/send-iloop.rs
index 71b8f12cdf00..d280b256b8ef 100644
--- a/src/test/run-pass/send-iloop.rs
+++ b/src/test/run-pass/send-iloop.rs
@@ -4,11 +4,11 @@ import std::task;
 import std::comm;
 import std::uint;
 
-fn# die(&&_i: ()) {
+fn die(&&_i: ()) {
     fail;
 }
 
-fn# iloop(&&_i: ()) {
+fn iloop(&&_i: ()) {
     task::unsupervise();
     task::spawn((), die);
     let p = comm::port::<()>();
diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs
index 7cf3e27c5f2d..f77a5dc4d1d9 100644
--- a/src/test/run-pass/spawn-fn.rs
+++ b/src/test/run-pass/spawn-fn.rs
@@ -4,7 +4,7 @@ use std;
 import std::task::yield;
 import std::task;
 
-fn# x(&&args: (str, int)) {
+fn x(&&args: (str, int)) {
     let (s, n) = args;
     log s; log n;
 }
diff --git a/src/test/run-pass/spawn-module-qualified.rs b/src/test/run-pass/spawn-module-qualified.rs
index ebac9fccb2bf..f04a4f8d8c7d 100644
--- a/src/test/run-pass/spawn-module-qualified.rs
+++ b/src/test/run-pass/spawn-module-qualified.rs
@@ -5,5 +5,5 @@ import std::task::spawn_joinable;
 fn main() { let x = spawn_joinable(10, m::child); join(x); }
 
 mod m {
-    fn# child(&&i: int) { log i; }
+    fn child(&&i: int) { log i; }
 }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index c67ce7475e88..70276916e897 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -12,7 +12,7 @@ import std::task;
 
 type ctx = comm::chan<int>;
 
-fn# iotask(&&args: (ctx, str)) {
+fn iotask(&&args: (ctx, str)) {
     let (cx, ip) = args;
     assert (str::eq(ip, "localhost"));
 }
diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
index c1752f1d23c9..ce15085ed5bf 100644
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -6,7 +6,7 @@ import std::task;
 
 fn main() { let t = task::spawn_joinable(10, child); task::join(t); }
 
-fn# child(&&i: int) { log_err i; assert (i == 10); }
+fn child(&&i: int) { log_err i; assert (i == 10); }
 
 // Local Variables:
 // mode: rust;
diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs
index a9acb1514caa..6060d316f39b 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -5,7 +5,7 @@ import std::task::spawn;
 
 fn main() { spawn((10, 20, 30, 40, 50, 60, 70, 80, 90), child); }
 
-fn# child(&&args: (int, int, int, int, int, int, int, int, int)) {
+fn child(&&args: (int, int, int, int, int, int, int, int, int)) {
     let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;
     log_err i1;
     log_err i2;
diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs
index 8c6f40bc93b6..e40f2c3d881e 100644
--- a/src/test/run-pass/task-comm-0.rs
+++ b/src/test/run-pass/task-comm-0.rs
@@ -7,7 +7,7 @@ import std::task;
 
 fn main() { test05(); }
 
-fn# test05_start(ch : chan<int>) {
+fn test05_start(ch : chan<int>) {
     log_err ch;
     send(ch, 10);
     log_err "sent 10";
diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs
index 0fcb00c50524..eb0e0819ed6e 100644
--- a/src/test/run-pass/task-comm-1.rs
+++ b/src/test/run-pass/task-comm-1.rs
@@ -5,7 +5,7 @@ import std::task::join;
 
 fn main() { test00(); }
 
-fn# start(&&_i: ()) { log "Started / Finished task."; }
+fn start(&&_i: ()) { log "Started / Finished task."; }
 
 fn test00() {
     let t = spawn_joinable((), start);
diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs
index 0938d8602d6c..12146aff5359 100644
--- a/src/test/run-pass/task-comm-10.rs
+++ b/src/test/run-pass/task-comm-10.rs
@@ -2,7 +2,7 @@ use std;
 import std::task;
 import std::comm;
 
-fn# start(c: comm::chan<comm::chan<str>>) {
+fn start(c: comm::chan<comm::chan<str>>) {
     let p = comm::port();
     comm::send(c, comm::chan(p));
 
diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs
index d427b4c1dd26..218ab723144e 100644
--- a/src/test/run-pass/task-comm-11.rs
+++ b/src/test/run-pass/task-comm-11.rs
@@ -2,7 +2,7 @@ use std;
 import std::comm;
 import std::task;
 
-fn# start(c: comm::chan<comm::chan<int>>) {
+fn start(c: comm::chan<comm::chan<int>>) {
     let p: comm::port<int> = comm::port();
     comm::send(c, comm::chan(p));
 }
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index 2d82a1fa1c8d..ca82b1614aea 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -3,7 +3,7 @@ import std::task;
 
 fn main() { test00(); }
 
-fn# start(&&task_number: int) { log "Started / Finished task."; }
+fn start(&&task_number: int) { log "Started / Finished task."; }
 
 fn test00() {
     let i: int = 0;
diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs
index f6a1efc0565b..d0f59698650b 100644
--- a/src/test/run-pass/task-comm-13.rs
+++ b/src/test/run-pass/task-comm-13.rs
@@ -3,7 +3,7 @@ import std::task;
 import std::comm;
 import std::comm::send;
 
-fn# start(&&args: (comm::chan<int>, int, int)) {
+fn start(&&args: (comm::chan<int>, int, int)) {
     let (c, start, number_of_messages) = args;
     let i: int = 0;
     while i < number_of_messages { send(c, start + i); i += 1; }
diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs
index e04e923d22d7..fda04fbe7fde 100644
--- a/src/test/run-pass/task-comm-14.rs
+++ b/src/test/run-pass/task-comm-14.rs
@@ -27,7 +27,7 @@ fn main() {
     log "main thread exiting";
 }
 
-fn# child(&&args: (int, comm::chan<int>)) {
+fn child(&&args: (int, comm::chan<int>)) {
     let (x, ch) = args;
     log x;
     comm::send(ch, x);
diff --git a/src/test/run-pass/task-comm-2.rs b/src/test/run-pass/task-comm-2.rs
index 5a07d1a9aace..239f636a72f2 100644
--- a/src/test/run-pass/task-comm-2.rs
+++ b/src/test/run-pass/task-comm-2.rs
@@ -5,7 +5,7 @@ import std::task;
 
 fn main() { log "===== SPAWNING and JOINING THREAD TASKS ====="; test00(); }
 
-fn# start(&&task_number: int) {
+fn start(&&task_number: int) {
     log "Started task.";
     let i: int = 0;
     while i < 10000 { i = i + 1; }
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 9ae26c254b81..18f14dd15a40 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -7,7 +7,7 @@ import std::comm::recv;
 
 fn main() { log "===== WITHOUT THREADS ====="; test00(); }
 
-fn# test00_start(&&args: (chan<int>, int, int)) {
+fn test00_start(&&args: (chan<int>, int, int)) {
     let (ch, message, count) = args;
     log "Starting test00_start";
     let i: int = 0;
diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs
index 2aca0058794a..2b7bcb371180 100644
--- a/src/test/run-pass/task-comm-7.rs
+++ b/src/test/run-pass/task-comm-7.rs
@@ -7,7 +7,7 @@ import comm::port;
 
 fn main() { test00(); }
 
-fn# test00_start(&&args: (comm::chan<int>, int, int)) {
+fn test00_start(&&args: (comm::chan<int>, int, int)) {
     let (c, start, number_of_messages) = args;
     let i: int = 0;
     while i < number_of_messages { comm::send(c, start + i); i += 1; }
diff --git a/src/test/run-pass/task-comm-8.rs b/src/test/run-pass/task-comm-8.rs
index 400336afe748..69202c286f78 100644
--- a/src/test/run-pass/task-comm-8.rs
+++ b/src/test/run-pass/task-comm-8.rs
@@ -4,7 +4,7 @@ import std::comm;
 
 fn main() { test00(); }
 
-fn# test00_start(&&args: (comm::chan<int>, int, int)) {
+fn test00_start(&&args: (comm::chan<int>, int, int)) {
     let (c, start, number_of_messages) = args;
     let i: int = 0;
     while i < number_of_messages { comm::send(c, start + i); i += 1; }
diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs
index b6c2bcb15b96..86c58cfbe70a 100644
--- a/src/test/run-pass/task-comm-9.rs
+++ b/src/test/run-pass/task-comm-9.rs
@@ -4,7 +4,7 @@ import std::comm;
 
 fn main() { test00(); }
 
-fn# test00_start(&&args: (comm::chan<int>, int)) {
+fn test00_start(&&args: (comm::chan<int>, int)) {
     let (c, number_of_messages) = args;
     let i: int = 0;
     while i < number_of_messages { comm::send(c, i + 0); i += 1; }
diff --git a/src/test/run-pass/task-life-0.rs b/src/test/run-pass/task-life-0.rs
index 5937232f3181..d40d397aa401 100644
--- a/src/test/run-pass/task-life-0.rs
+++ b/src/test/run-pass/task-life-0.rs
@@ -2,6 +2,6 @@ use std;
 import std::task;
 fn main() { task::spawn("Hello", child); }
 
-fn# child(&&s: str) {
+fn child(&&s: str) {
 
 }
diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs
index ca67e2ead6e4..4c73e31e1b7f 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/src/test/run-pass/terminate-in-initializer.rs
@@ -11,13 +11,13 @@ fn test_cont() { let i = 0; while i < 1 { i += 1; let x: @int = cont; } }
 fn test_ret() { let x: @int = ret; }
 
 fn test_fail() {
-    fn# f(&&_i: ()) { std::task::unsupervise(); let x: @int = fail; }
+    fn f(&&_i: ()) { std::task::unsupervise(); let x: @int = fail; }
     std::task::spawn((), f);
 }
 
 fn test_fail_indirect() {
     fn f() -> ! { fail; }
-    fn# g(&&_i: ()) { std::task::unsupervise(); let x: @int = f(); }
+    fn g(&&_i: ()) { std::task::unsupervise(); let x: @int = f(); }
     std::task::spawn((), g);
 }
 
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index 64f79848caa6..0c149769113e 100644
--- a/src/test/run-pass/threads.rs
+++ b/src/test/run-pass/threads.rs
@@ -9,5 +9,5 @@ fn main() {
     log "main thread exiting";
 }
 
-fn# child(&&x: int) { log x; }
+fn child(&&x: int) { log x; }
 
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index 2fa17677150b..57d8ff2e4de6 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -3,7 +3,7 @@ import std::comm;
 import std::task;
 import std::uint;
 
-fn# child(args: (comm::chan<~uint>, uint)) {
+fn child(args: (comm::chan<~uint>, uint)) {
     let (c, i) = args;
     comm::send(c, ~i);
 }
diff --git a/src/test/run-pass/unwind-box.rs b/src/test/run-pass/unwind-box.rs
index 8b678a0a1a74..a6f08923433e 100644
--- a/src/test/run-pass/unwind-box.rs
+++ b/src/test/run-pass/unwind-box.rs
@@ -2,7 +2,7 @@
 use std;
 import std::task;
 
-fn# f(&&_i: ()) {
+fn f(&&_i: ()) {
     task::unsupervise();
     let a = @0;
     fail;
diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs
index b5c79b07015a..b47fcd7ef2d2 100644
--- a/src/test/run-pass/unwind-resource.rs
+++ b/src/test/run-pass/unwind-resource.rs
@@ -7,7 +7,7 @@ resource complainer(c: comm::chan<bool>) {
     comm::send(c, true);
 }
 
-fn# f(c: comm::chan<bool>) {
+fn f(c: comm::chan<bool>) {
     task::unsupervise();
     let c <- complainer(c);
     fail;
diff --git a/src/test/run-pass/unwind-resource2.rs b/src/test/run-pass/unwind-resource2.rs
index a7eab7f7eeba..34a80ed33ea6 100644
--- a/src/test/run-pass/unwind-resource2.rs
+++ b/src/test/run-pass/unwind-resource2.rs
@@ -6,7 +6,7 @@ import std::comm;
 resource complainer(c: @int) {
 }
 
-fn# f(&&_i: ()) {
+fn f(&&_i: ()) {
     task::unsupervise();
     let c <- complainer(@0);
     fail;
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index 9bc34db3b5a8..071fa594a84f 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -2,7 +2,7 @@
 use std;
 import std::task;
 
-fn# f(&&_i: ()) {
+fn f(&&_i: ()) {
     task::unsupervise();
     let a = ~0;
     fail;
diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs
index 7b7a9d53b03d..19701b54b797 100644
--- a/src/test/run-pass/yield.rs
+++ b/src/test/run-pass/yield.rs
@@ -13,6 +13,6 @@ fn main() {
     join(other);
 }
 
-fn# child(&&_i: ()) {
+fn child(&&_i: ()) {
     log_err "4"; yield(); log_err "5"; yield(); log_err "6";
 }
diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs
index 945e3da86e7a..138c09cffcc9 100644
--- a/src/test/run-pass/yield1.rs
+++ b/src/test/run-pass/yield1.rs
@@ -10,4 +10,4 @@ fn main() {
     join(other);
 }
 
-fn# child(&&_i: ()) { log_err "2"; }
+fn child(&&_i: ()) { log_err "2"; }
diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs
index 8ed8b56af3df..1349831cb87f 100644
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -15,25 +15,25 @@ fn test_unsupervise() { }
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "linux")]
 fn test_unsupervise() {
-    fn# f(&&_i: ()) { task::unsupervise(); fail; }
+    fn f(&&_i: ()) { task::unsupervise(); fail; }
     task::spawn((), f);
 }
 
 #[test]
 fn test_lib_spawn() {
-    fn# foo(&&_i: ()) { log_err "Hello, World!"; }
+    fn foo(&&_i: ()) { log_err "Hello, World!"; }
     task::spawn((), foo);
 }
 
 #[test]
 fn test_lib_spawn2() {
-    fn# foo(&&x: int) { assert (x == 42); }
+    fn foo(&&x: int) { assert (x == 42); }
     task::spawn(42, foo);
 }
 
 #[test]
 fn test_join_chan() {
-    fn# winner(&&_i: ()) { }
+    fn winner(&&_i: ()) { }
 
     let p = comm::port();
     task::spawn_notify((), winner, comm::chan(p));
@@ -56,7 +56,7 @@ fn test_join_chan_fail() { }
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "linux")]
 fn test_join_chan_fail() {
-    fn# failer(&&_i: ()) { task::unsupervise(); fail }
+    fn failer(&&_i: ()) { task::unsupervise(); fail }
 
     let p = comm::port();
     task::spawn_notify((), failer, comm::chan(p));
@@ -71,7 +71,7 @@ fn test_join_chan_fail() {
 
 #[test]
 fn test_join_convenient() {
-    fn# winner(&&_i: ()) { }
+    fn winner(&&_i: ()) { }
     let handle = task::spawn_joinable((), winner);
     assert (task::tr_success == task::join(handle));
 }
@@ -80,7 +80,7 @@ fn test_join_convenient() {
 #[ignore]
 fn spawn_polymorphic() {
     // FIXME #1038: Can't spawn palymorphic functions
-    /*fn# foo<~T>(x: T) { log_err x; }
+    /*fn foo<~T>(x: T) { log_err x; }
 
     task::spawn(true, foo);
     task::spawn(42, foo);*/