remove all kind annotations from closures

123 files changed, 214 insertions, 209 deletions

diff --git a/src/test/auxiliary/issue-18711.rs b/src/test/auxiliary/issue-18711.rs
index 54f1595780d..a29dcc00cdd 100644
--- a/src/test/auxiliary/issue-18711.rs
+++ b/src/test/auxiliary/issue-18711.rs
@@ -12,5 +12,5 @@
 #![crate_type = "rlib"]
 
 pub fn inner<F>(f: F) -> F {
-    (move |:| f)()
+    (move || f)()
 }
diff --git a/src/test/auxiliary/logging_right_crate.rs b/src/test/auxiliary/logging_right_crate.rs
index 67037a3ac9e..bf4ab975ced 100644
--- a/src/test/auxiliary/logging_right_crate.rs
+++ b/src/test/auxiliary/logging_right_crate.rs
@@ -12,5 +12,5 @@
 
 pub fn foo<T>() {
     fn death() -> int { panic!() }
-    debug!("{}", (|&:|{ death() })());
+    debug!("{}", (||{ death() })());
 }
diff --git a/src/test/auxiliary/unboxed-closures-cross-crate.rs b/src/test/auxiliary/unboxed-closures-cross-crate.rs
index 4bc45caa170..f03bcb41faf 100644
--- a/src/test/auxiliary/unboxed-closures-cross-crate.rs
+++ b/src/test/auxiliary/unboxed-closures-cross-crate.rs
@@ -15,14 +15,14 @@ use std::ops::Add;
 #[inline]
 pub fn has_closures() -> uint {
     let x = 1u;
-    let mut f = move |&mut:| x;
+    let mut f = move || x;
     let y = 1u;
-    let g = |:| y;
+    let g = || y;
     f() + g()
 }
 
 pub fn has_generic_closures<T: Add<Output=T> + Copy>(x: T, y: T) -> T {
-    let mut f = move |&mut:| x;
-    let g = |:| y;
+    let mut f = move || x;
+    let g = || y;
     f() + g()
 }
diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs
index 3a35bea0d59..dd8e7fdfbde 100644
--- a/src/test/bench/shootout-reverse-complement.rs
+++ b/src/test/bench/shootout-reverse-complement.rs
@@ -251,6 +251,6 @@ fn parallel<'a, I, T, F>(iter: I, f: F)
 fn main() {
     let mut data = read_to_end(&mut stdin_raw()).unwrap();
     let tables = &Tables::new();
-    parallel(mut_dna_seqs(data.as_mut_slice()), |&: seq| reverse_complement(seq, tables));
+    parallel(mut_dna_seqs(data.as_mut_slice()), |seq| reverse_complement(seq, tables));
     stdout_raw().write(data.as_mut_slice()).unwrap();
 }
diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs
index 0694420e766..b8aba7c483d 100644
--- a/src/test/compile-fail/assign-to-method.rs
+++ b/src/test/compile-fail/assign-to-method.rs
@@ -27,5 +27,5 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 
 fn main() {
   let nyan : cat = cat(52us, 99);
-  nyan.speak = |&:| println!("meow"); //~ ERROR attempted to take value of method
+  nyan.speak = || println!("meow"); //~ ERROR attempted to take value of method
 }
diff --git a/src/test/compile-fail/blind-item-local-shadow.rs b/src/test/compile-fail/blind-item-local-shadow.rs
index a28f5f6e557..5cc087cb66e 100644
--- a/src/test/compile-fail/blind-item-local-shadow.rs
+++ b/src/test/compile-fail/blind-item-local-shadow.rs
@@ -13,7 +13,7 @@ mod bar {
 }
 
 fn main() {
-    let foo = |&:| false;
+    let foo = || false;
     use bar::foo;
     //~^ ERROR imports are not allowed after non-item statements
     assert_eq!(foo(), false);
diff --git a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
index 9b9edce243b..9ea5fbbdb1a 100644
--- a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
+++ b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
@@ -49,15 +49,15 @@ fn test5(f: &mut Test) {
 }
 
 fn test6() {
-    let mut f = |&mut:| {};
-    (|&mut:| {
+    let mut f = || {};
+    (|| {
         f();
     })();
 }
 
 fn test7() {
     fn foo<F>(_: F) where F: FnMut(Box<FnMut(isize)>, isize) {}
-    let mut f = |&mut: g: Box<FnMut(isize)>, b: isize| {};
+    let mut f = |g: Box<FnMut(isize)>, b: isize| {};
     f(box |a| {
         foo(f);
         //~^ ERROR cannot move `f` into closure because it is borrowed
diff --git a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
index 9d73ad319a6..851b11fac2b 100644
--- a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
@@ -23,37 +23,37 @@ fn set(x: &mut isize) {
 
 fn a() {
     let mut x = 3;
-    let c1 = |&mut:| x = 4;
-    let c2 = |&mut:| x * 5; //~ ERROR cannot borrow `x`
+    let c1 = || x = 4;
+    let c2 = || x * 5; //~ ERROR cannot borrow `x`
 }
 
 fn b() {
     let mut x = 3;
-    let c1 = |&mut:| set(&mut x);
-    let c2 = |&mut:| get(&x); //~ ERROR cannot borrow `x`
+    let c1 = || set(&mut x);
+    let c2 = || get(&x); //~ ERROR cannot borrow `x`
 }
 
 fn c() {
     let mut x = 3;
-    let c1 = |&mut:| set(&mut x);
-    let c2 = |&mut:| x * 5; //~ ERROR cannot borrow `x`
+    let c1 = || set(&mut x);
+    let c2 = || x * 5; //~ ERROR cannot borrow `x`
 }
 
 fn d() {
     let mut x = 3;
-    let c2 = |&mut:| x * 5;
+    let c2 = || x * 5;
     x = 5; //~ ERROR cannot assign
 }
 
 fn e() {
     let mut x = 3;
-    let c1 = |&mut:| get(&x);
+    let c1 = || get(&x);
     x = 5; //~ ERROR cannot assign
 }
 
 fn f() {
     let mut x = box 3;
-    let c1 = |&mut:| get(&*x);
+    let c1 = || get(&*x);
     *x = 5; //~ ERROR cannot assign
 }
 
@@ -63,7 +63,7 @@ fn g() {
     }
 
     let mut x = box Foo { f: box 3 };
-    let c1 = |&mut:| get(&*x.f);
+    let c1 = || get(&*x.f);
     *x.f = 5; //~ ERROR cannot assign to `*x.f`
 }
 
@@ -73,8 +73,8 @@ fn h() {
     }
 
     let mut x = box Foo { f: box 3 };
-    let c1 = |&mut:| get(&*x.f);
-    let c2 = |&mut:| *x.f = 5; //~ ERROR cannot borrow `x` as mutable
+    let c1 = || get(&*x.f);
+    let c2 = || *x.f = 5; //~ ERROR cannot borrow `x` as mutable
 }
 
 fn main() {
diff --git a/src/test/compile-fail/borrowck-closures-mut-of-imm.rs b/src/test/compile-fail/borrowck-closures-mut-of-imm.rs
index 82607741909..40f9be2dd82 100644
--- a/src/test/compile-fail/borrowck-closures-mut-of-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-mut-of-imm.rs
@@ -20,9 +20,9 @@ fn set(x: &mut isize) {
 }
 
 fn a(x: &isize) {
-    let c1 = |&mut:| set(&mut *x);
+    let c1 = || set(&mut *x);
     //~^ ERROR cannot borrow
-    let c2 = |&mut:| set(&mut *x);
+    let c2 = || set(&mut *x);
     //~^ ERROR cannot borrow
     //~| ERROR closure requires unique access
 }
diff --git a/src/test/compile-fail/borrowck-closures-two-mut.rs b/src/test/compile-fail/borrowck-closures-two-mut.rs
index 48a9dccfef0..8ab4e257b06 100644
--- a/src/test/compile-fail/borrowck-closures-two-mut.rs
+++ b/src/test/compile-fail/borrowck-closures-two-mut.rs
@@ -14,10 +14,12 @@
 
 #![feature(box_syntax)]
 
+fn to_fn_mut<F: FnMut()>(f: F) -> F { f }
+
 fn a() {
     let mut x = 3;
-    let c1 = |&mut:| x = 4;
-    let c2 = |&mut:| x = 5; //~ ERROR cannot borrow `x` as mutable more than once
+    let c1 = to_fn_mut(|| x = 4);
+    let c2 = to_fn_mut(|| x = 5); //~ ERROR cannot borrow `x` as mutable more than once
 }
 
 fn set(x: &mut isize) {
@@ -26,20 +28,20 @@ fn set(x: &mut isize) {
 
 fn b() {
     let mut x = 3;
-    let c1 = |&mut:| set(&mut x);
-    let c2 = |&mut:| set(&mut x); //~ ERROR cannot borrow `x` as mutable more than once
+    let c1 = to_fn_mut(|| set(&mut x));
+    let c2 = to_fn_mut(|| set(&mut x)); //~ ERROR cannot borrow `x` as mutable more than once
 }
 
 fn c() {
     let mut x = 3;
-    let c1 = |&mut:| x = 5;
-    let c2 = |&mut:| set(&mut x); //~ ERROR cannot borrow `x` as mutable more than once
+    let c1 = to_fn_mut(|| x = 5);
+    let c2 = to_fn_mut(|| set(&mut x)); //~ ERROR cannot borrow `x` as mutable more than once
 }
 
 fn d() {
     let mut x = 3;
-    let c1 = |&mut:| x = 5;
-    let c2 = |&mut:| { let _y = |&mut:| set(&mut x); }; // (nested closure)
+    let c1 = to_fn_mut(|| x = 5);
+    let c2 = to_fn_mut(|| { let _y = to_fn_mut(|| set(&mut x)); }); // (nested closure)
     //~^ ERROR cannot borrow `x` as mutable more than once
 }
 
@@ -49,8 +51,8 @@ fn g() {
     }
 
     let mut x = box Foo { f: box 3 };
-    let c1 = |&mut:| set(&mut *x.f);
-    let c2 = |&mut:| set(&mut *x.f);
+    let c1 = to_fn_mut(|| set(&mut *x.f));
+    let c2 = to_fn_mut(|| set(&mut *x.f));
     //~^ ERROR cannot borrow `x` as mutable more than once
 }
 
diff --git a/src/test/compile-fail/borrowck-closures-unique-imm.rs b/src/test/compile-fail/borrowck-closures-unique-imm.rs
index cf86602af0b..dcf43c01e17 100644
--- a/src/test/compile-fail/borrowck-closures-unique-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-unique-imm.rs
@@ -16,7 +16,7 @@ pub fn main() {
     let mut this = &mut Foo {
         x: 1,
     };
-    let mut r = |&mut:| {
+    let mut r = || {
         let p = &this.x;
         &mut this.x; //~ ERROR cannot borrow
     };
diff --git a/src/test/compile-fail/borrowck-closures-unique.rs b/src/test/compile-fail/borrowck-closures-unique.rs
index f9a6d5ac845..9410181659c 100644
--- a/src/test/compile-fail/borrowck-closures-unique.rs
+++ b/src/test/compile-fail/borrowck-closures-unique.rs
@@ -23,27 +23,27 @@ fn set(x: &mut isize) -> isize {
 }
 
 fn a(x: &mut isize) {
-    let c1 = |&mut:| get(x);
-    let c2 = |&mut:| get(x);
+    let c1 = || get(x);
+    let c2 = || get(x);
 }
 
 fn b(x: &mut isize) {
-    let c1 = |&mut:| get(x);
-    let c2 = |&mut:| set(x); //~ ERROR closure requires unique access to `x`
+    let c1 = || get(x);
+    let c2 = || set(x); //~ ERROR closure requires unique access to `x`
 }
 
 fn c(x: &mut isize) {
-    let c1 = |&mut:| get(x);
-    let c2 = |&mut:| { get(x); set(x); }; //~ ERROR closure requires unique access to `x`
+    let c1 = || get(x);
+    let c2 = || { get(x); set(x); }; //~ ERROR closure requires unique access to `x`
 }
 
 fn d(x: &mut isize) {
-    let c1 = |&mut:| set(x);
-    let c2 = |&mut:| set(x); //~ ERROR closure requires unique access to `x`
+    let c1 = || set(x);
+    let c2 = || set(x); //~ ERROR closure requires unique access to `x`
 }
 
 fn e(x: &mut isize) {
-    let c1 = |&mut:| x = panic!(); //~ ERROR closure cannot assign to immutable local variable
+    let c1 = || x = panic!(); //~ ERROR closure cannot assign to immutable local variable
 }
 
 fn main() {
diff --git a/src/test/compile-fail/borrowck-closures-use-after-free.rs b/src/test/compile-fail/borrowck-closures-use-after-free.rs
index b6529da1883..32cd364d1f2 100644
--- a/src/test/compile-fail/borrowck-closures-use-after-free.rs
+++ b/src/test/compile-fail/borrowck-closures-use-after-free.rs
@@ -26,7 +26,7 @@ impl Drop for Foo {
 
 fn main() {
   let mut ptr = box Foo { x: 0 };
-  let mut test = |&mut: foo: &Foo| {
+  let mut test = |foo: &Foo| {
     ptr = box Foo { x: ptr.x + 1 };
   };
   test(&*ptr); //~ ERROR cannot borrow `*ptr`
diff --git a/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs b/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs
index 3c20abab8bd..5b32fd2d198 100644
--- a/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs
+++ b/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let j = |&:| -> isize {
+    let j = || -> isize {
         let i: isize;
         i //~ ERROR use of possibly uninitialized variable: `i`
     };
diff --git a/src/test/compile-fail/borrowck-init-in-fn-expr.rs b/src/test/compile-fail/borrowck-init-in-fn-expr.rs
index 31ca39c3f9b..65f1a1fa098 100644
--- a/src/test/compile-fail/borrowck-init-in-fn-expr.rs
+++ b/src/test/compile-fail/borrowck-init-in-fn-expr.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let f  = |&:| -> isize {
+    let f  = || -> isize {
         let i: isize;
         i //~ ERROR use of possibly uninitialized variable: `i`
     };
diff --git a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
index c3a1e808e37..7093da6803c 100644
--- a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
+++ b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
@@ -32,7 +32,7 @@ fn foo() {
 
 fn bar() {
     // Original borrow ends at end of closure
-    |&:| {
+    || {
         let mut x = 1us;
         let y = &mut x;
         let z = &mut x; //~ ERROR cannot borrow
diff --git a/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs b/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs
index 738755855c0..e59bd62d178 100644
--- a/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs
+++ b/src/test/compile-fail/cannot-mutate-captured-non-mut-var.rs
@@ -14,10 +14,10 @@ fn to_fn_once<A,F:FnOnce<A>>(f: F) -> F { f }
 
 fn main() {
     let x = 1;
-    to_fn_once(move|:| { x = 2; });
+    to_fn_once(move|| { x = 2; });
     //~^ ERROR: cannot assign to immutable captured outer variable
 
     let s = std::old_io::stdin();
-    to_fn_once(move|:| { s.read_to_end(); });
+    to_fn_once(move|| { s.read_to_end(); });
     //~^ ERROR: cannot borrow immutable captured outer variable
 }
diff --git a/src/test/compile-fail/closure-reform-bad.rs b/src/test/compile-fail/closure-reform-bad.rs
index ef01c96adde..d2295eba6d7 100644
--- a/src/test/compile-fail/closure-reform-bad.rs
+++ b/src/test/compile-fail/closure-reform-bad.rs
@@ -17,7 +17,7 @@ fn call_bare(f: fn(&str)) {
 
 fn main() {
     let string = "world!";
-    let f = |&: s: &str| println!("{}{}", s, string);
+    let f = |s: &str| println!("{}{}", s, string);
     call_bare(f)    //~ ERROR mismatched types
 }
 
diff --git a/src/test/compile-fail/dead-code-closure-bang.rs b/src/test/compile-fail/dead-code-closure-bang.rs
index 46f5f41d728..280e2ed0952 100644
--- a/src/test/compile-fail/dead-code-closure-bang.rs
+++ b/src/test/compile-fail/dead-code-closure-bang.rs
@@ -13,7 +13,7 @@
 #![deny(unreachable_code)]
 
 fn main() {
-    let x = |:| panic!();
+    let x = || panic!();
     x();
     std::io::println("Foo bar"); //~ ERROR: unreachable statement
 }
diff --git a/src/test/compile-fail/fn-trait-formatting.rs b/src/test/compile-fail/fn-trait-formatting.rs
index f8e7dc11828..71e1f7091b2 100644
--- a/src/test/compile-fail/fn-trait-formatting.rs
+++ b/src/test/compile-fail/fn-trait-formatting.rs
@@ -14,20 +14,20 @@
 fn needs_fn<F>(x: F) where F: Fn(isize) -> isize {}
 
 fn main() {
-    let _: () = (box |:_: isize| {}) as Box<FnOnce(isize)>;
+    let _: () = (box |_: isize| {}) as Box<FnOnce(isize)>;
     //~^ ERROR object-safe
     //~| ERROR mismatched types
     //~| expected `()`
     //~| found `Box<core::ops::FnOnce(isize)>`
     //~| expected ()
     //~| found box
-    let _: () = (box |&:_: isize, isize| {}) as Box<Fn(isize, isize)>;
+    let _: () = (box |_: isize, isize| {}) as Box<Fn(isize, isize)>;
     //~^ ERROR mismatched types
     //~| expected `()`
     //~| found `Box<core::ops::Fn(isize, isize)>`
     //~| expected ()
     //~| found box
-    let _: () = (box |&mut:| -> isize unimplemented!()) as Box<FnMut() -> isize>;
+    let _: () = (box || -> isize unimplemented!()) as Box<FnMut() -> isize>;
     //~^ ERROR mismatched types
     //~| expected `()`
     //~| found `Box<core::ops::FnMut() -> isize>`
diff --git a/src/test/compile-fail/immut-function-arguments.rs b/src/test/compile-fail/immut-function-arguments.rs
index 99927d8b9bf..949c1c0d9c4 100644
--- a/src/test/compile-fail/immut-function-arguments.rs
+++ b/src/test/compile-fail/immut-function-arguments.rs
@@ -14,7 +14,7 @@ fn f(y: Box<isize>) {
 }
 
 fn g() {
-    let _frob = |&: q: Box<isize>| { *q = 2; }; //~ ERROR cannot assign
+    let _frob = |q: Box<isize>| { *q = 2; }; //~ ERROR cannot assign
 
 }
 
diff --git a/src/test/compile-fail/issue-10398.rs b/src/test/compile-fail/issue-10398.rs
index 5ee693d97a8..736f9630127 100644
--- a/src/test/compile-fail/issue-10398.rs
+++ b/src/test/compile-fail/issue-10398.rs
@@ -12,7 +12,7 @@
 
 fn main() {
     let x = box 1;
-    let f = move|:| {
+    let f = move|| {
         let _a = x;
         drop(x);
         //~^ ERROR: use of moved value: `x`
diff --git a/src/test/compile-fail/issue-11192.rs b/src/test/compile-fail/issue-11192.rs
index 0d7a846bff6..a95bcc73a9c 100644
--- a/src/test/compile-fail/issue-11192.rs
+++ b/src/test/compile-fail/issue-11192.rs
@@ -22,7 +22,7 @@ impl Drop for Foo {
 
 fn main() {
     let mut ptr = box Foo { x: 0 };
-    let mut test = |&mut: foo: &Foo| {
+    let mut test = |foo: &Foo| {
         println!("access {}", foo.x);
         ptr = box Foo { x: ptr.x + 1 };
         println!("access {}", foo.x);
diff --git a/src/test/compile-fail/issue-11873.rs b/src/test/compile-fail/issue-11873.rs
index f9a523641e4..38956944f63 100644
--- a/src/test/compile-fail/issue-11873.rs
+++ b/src/test/compile-fail/issue-11873.rs
@@ -10,7 +10,7 @@
 
 fn main() {
     let mut v = vec!(1);
-    let mut f = |&mut:| v.push(2);
+    let mut f = || v.push(2);
     let _w = v; //~ ERROR: cannot move out of `v`
 
     f();
diff --git a/src/test/compile-fail/issue-16939.rs b/src/test/compile-fail/issue-16939.rs
index 9d2212b69ce..7ec3fef5c87 100644
--- a/src/test/compile-fail/issue-16939.rs
+++ b/src/test/compile-fail/issue-16939.rs
@@ -14,7 +14,7 @@
 // wrong arity.
 
 fn _foo<F: Fn()> (f: F) {
-    |&: t| f(t); //~ ERROR E0057
+    |t| f(t); //~ ERROR E0057
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-17551.rs b/src/test/compile-fail/issue-17551.rs
index 3889b6f4f7d..b19a7703b85 100644
--- a/src/test/compile-fail/issue-17551.rs
+++ b/src/test/compile-fail/issue-17551.rs
@@ -14,5 +14,5 @@ struct B<T>;
 
 fn main() {
     let foo = B;
-    let closure = |:| foo; //~ ERROR unable to infer enough type information
+    let closure = || foo; //~ ERROR unable to infer enough type information
 }
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
index fbecd0487bf..1cdf48e291c 100644
--- a/src/test/compile-fail/issue-17651.rs
+++ b/src/test/compile-fail/issue-17651.rs
@@ -14,7 +14,7 @@
 #![feature(box_syntax)]
 
 fn main() {
-    (|&:| box *[0us].as_slice())();
+    (|| box *[0us].as_slice())();
     //~^ ERROR cannot move out of borrowed content
     //~^^ ERROR cannot move a value of type [usize]
 }
diff --git a/src/test/compile-fail/issue-2149.rs b/src/test/compile-fail/issue-2149.rs
index 45b7bebfc28..37dbcaf39bd 100644
--- a/src/test/compile-fail/issue-2149.rs
+++ b/src/test/compile-fail/issue-2149.rs
@@ -20,6 +20,6 @@ impl<A> vec_monad<A> for Vec<A> {
    }
 }
 fn main() {
-    ["hi"].bind(|&mut: x| [x] );
+    ["hi"].bind(|x| [x] );
     //~^ ERROR type `[&str; 1]` does not implement any method in scope named `bind`
 }
diff --git a/src/test/compile-fail/issue-3044.rs b/src/test/compile-fail/issue-3044.rs
index c67d6b1ce8f..0f7cc2cb72b 100644
--- a/src/test/compile-fail/issue-3044.rs
+++ b/src/test/compile-fail/issue-3044.rs
@@ -11,7 +11,7 @@
 
 fn main() {
     let needlesArr: Vec<char> = vec!('a', 'f');
-    needlesArr.iter().fold(|&: x, y| {
+    needlesArr.iter().fold(|x, y| {
     });
     //~^^ ERROR this function takes 2 parameters but 1 parameter was supplied
     //
diff --git a/src/test/compile-fail/issue-3563.rs b/src/test/compile-fail/issue-3563.rs
index 7ebc5b7a5b9..0e1cc18dba9 100644
--- a/src/test/compile-fail/issue-3563.rs
+++ b/src/test/compile-fail/issue-3563.rs
@@ -10,7 +10,7 @@
 
 trait A {
     fn a(&self) {
-        |&:| self.b()
+        || self.b()
         //~^ ERROR type `&Self` does not implement any method in scope named `b`
         //~| ERROR mismatched types
         //~| expected `()`
diff --git a/src/test/compile-fail/issue-4335.rs b/src/test/compile-fail/issue-4335.rs
index 3d44c1a52d4..d0da51373d9 100644
--- a/src/test/compile-fail/issue-4335.rs
+++ b/src/test/compile-fail/issue-4335.rs
@@ -14,7 +14,7 @@
 fn id<T>(t: T) -> T { t }
 
 fn f<'r, T>(v: &'r T) -> Box<FnMut() -> T + 'r> {
-    id(box |&mut:| *v) //~ ERROR cannot infer
+    id(box || *v) //~ ERROR cannot infer
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-5239-1.rs b/src/test/compile-fail/issue-5239-1.rs
index 0eaa40efca2..49a43ee37ad 100644
--- a/src/test/compile-fail/issue-5239-1.rs
+++ b/src/test/compile-fail/issue-5239-1.rs
@@ -11,6 +11,6 @@
 // Regression test for issue #5239
 
 fn main() {
-    let x = |&: ref x: isize| -> isize { x += 1; };
+    let x = |ref x: isize| -> isize { x += 1; };
     //~^ ERROR binary assignment operation `+=` cannot be applied to type `&isize`
 }
diff --git a/src/test/compile-fail/issue-6801.rs b/src/test/compile-fail/issue-6801.rs
index 9424ff22dc7..9e797019392 100644
--- a/src/test/compile-fail/issue-6801.rs
+++ b/src/test/compile-fail/issue-6801.rs
@@ -24,7 +24,7 @@ fn invoke<F>(f: F) where F: FnOnce() -> usize {
 
 fn main() {
       let x  : Box<usize>  = box 9;
-      let sq =  |:| { *x * *x };
+      let sq =  || { *x * *x };
 
       twice(x); //~ ERROR: cannot move out of
       invoke(sq);
diff --git a/src/test/compile-fail/issue-7573.rs b/src/test/compile-fail/issue-7573.rs
index c15c556f5d6..2d1cea1d44b 100644
--- a/src/test/compile-fail/issue-7573.rs
+++ b/src/test/compile-fail/issue-7573.rs
@@ -25,7 +25,7 @@ impl CrateId {
 
 pub fn remove_package_from_database() {
     let mut lines_to_use: Vec<&CrateId> = Vec::new();
-    let push_id = |&mut: installed_id: &CrateId| {
+    let push_id = |installed_id: &CrateId| {
         lines_to_use.push(installed_id);
         //~^ ERROR cannot infer an appropriate lifetime for automatic coercion due to
         // conflicting requirements
diff --git a/src/test/compile-fail/lint-unused-mut-variables.rs b/src/test/compile-fail/lint-unused-mut-variables.rs
index ddba7b58afa..dcc82b8920f 100644
--- a/src/test/compile-fail/lint-unused-mut-variables.rs
+++ b/src/test/compile-fail/lint-unused-mut-variables.rs
@@ -35,7 +35,7 @@ fn main() {
       _ => {}
     }
 
-    let x = |&: mut y: isize| 10; //~ ERROR: variable does not need to be mutable
+    let x = |mut y: isize| 10; //~ ERROR: variable does not need to be mutable
     fn what(mut foo: isize) {} //~ ERROR: variable does not need to be mutable
 
     // positive cases
@@ -65,7 +65,7 @@ fn main() {
       _ => {}
     }
 
-    let x = |&mut: mut y: isize| y = 32;
+    let x = |mut y: isize| y = 32;
     fn nothing(mut foo: isize) { foo = 37; }
 
     // leading underscore should avoid the warning, just like the
diff --git a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs
index 53f923e5061..be42f0f0ed8 100644
--- a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs
+++ b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let f = |&: 3: isize| println!("hello");
+    let f = |3: isize| println!("hello");
     //~^ ERROR refutable pattern in function argument: `_` not covered
     f(4);
 }
diff --git a/src/test/compile-fail/region-bound-on-closure-outlives-call.rs b/src/test/compile-fail/region-bound-on-closure-outlives-call.rs
index 5b04fa3d87c..9f35c636b45 100644
--- a/src/test/compile-fail/region-bound-on-closure-outlives-call.rs
+++ b/src/test/compile-fail/region-bound-on-closure-outlives-call.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn call_rec<F>(mut f: F) -> usize where F: FnMut(usize) -> usize {
-    (|&mut: x| f(x))(call_rec(f)) //~ ERROR cannot move out of `f`
+    (|x| f(x))(call_rec(f)) //~ ERROR cannot move out of `f`
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs b/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs
index cdaa3468a46..9418156ffcd 100644
--- a/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs
+++ b/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs
@@ -17,7 +17,7 @@ fn main() {
     {
         let c = 1;
         let c_ref = &c; //~ ERROR `c` does not live long enough
-        f = move |&mut: a: isize, b: isize| { a + b + *c_ref };
+        f = move |a: isize, b: isize| { a + b + *c_ref };
     }
 }
 
diff --git a/src/test/compile-fail/regions-addr-of-upvar-self.rs b/src/test/compile-fail/regions-addr-of-upvar-self.rs
index fa76ab758ab..70d5fe83055 100644
--- a/src/test/compile-fail/regions-addr-of-upvar-self.rs
+++ b/src/test/compile-fail/regions-addr-of-upvar-self.rs
@@ -16,7 +16,7 @@ struct dog {
 
 impl dog {
     pub fn chase_cat(&mut self) {
-        let _f = |&:| {
+        let _f = || {
             let p: &'static mut usize = &mut self.food; //~ ERROR cannot infer
             *p = 3us;
         };
diff --git a/src/test/compile-fail/regions-escape-unboxed-closure.rs b/src/test/compile-fail/regions-escape-unboxed-closure.rs
index 06768fa6880..abbefd25488 100644
--- a/src/test/compile-fail/regions-escape-unboxed-closure.rs
+++ b/src/test/compile-fail/regions-escape-unboxed-closure.rs
@@ -15,5 +15,5 @@ fn with_int(f: &mut FnMut(&isize)) {
 
 fn main() {
     let mut x: Option<&isize> = None;
-    with_int(&mut |&mut: y| x = Some(y));   //~ ERROR cannot infer
+    with_int(&mut |y| x = Some(y));   //~ ERROR cannot infer
 }
diff --git a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
index 21586f78db3..2e3531a2e8f 100644
--- a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
+++ b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
@@ -16,7 +16,7 @@ fn main() {
     // Unboxed closure case
     {
         let mut x = 0us;
-        let mut f = |&mut:| &mut x; //~ ERROR cannot infer
+        let mut f = || &mut x; //~ ERROR cannot infer
         let x = f();
         let y = f();
     }
diff --git a/src/test/compile-fail/unboxed-closure-immutable-capture.rs b/src/test/compile-fail/unboxed-closure-immutable-capture.rs
index ebdd3c3107f..145b2bfaedd 100644
--- a/src/test/compile-fail/unboxed-closure-immutable-capture.rs
+++ b/src/test/compile-fail/unboxed-closure-immutable-capture.rs
@@ -18,14 +18,14 @@ fn set(x: &mut usize) { *x = 0; }
 
 fn main() {
     let x = 0us;
-    move |&mut:| x = 1; //~ ERROR cannot assign
-    move |&mut:| set(&mut x); //~ ERROR cannot borrow
-    move |:| x = 1; //~ ERROR cannot assign
-    move |:| set(&mut x); //~ ERROR cannot borrow
-    |&mut:| x = 1; //~ ERROR cannot assign
+    move || x = 1; //~ ERROR cannot assign
+    move || set(&mut x); //~ ERROR cannot borrow
+    move || x = 1; //~ ERROR cannot assign
+    move || set(&mut x); //~ ERROR cannot borrow
+    || x = 1; //~ ERROR cannot assign
     // FIXME: this should be `cannot borrow` (issue #18330)
-    |&mut:| set(&mut x); //~ ERROR cannot assign
-    |:| x = 1; //~ ERROR cannot assign
+    || set(&mut x); //~ ERROR cannot assign
+    || x = 1; //~ ERROR cannot assign
     // FIXME: this should be `cannot borrow` (issue #18330)
-    |:| set(&mut x); //~ ERROR cannot assign
+    || set(&mut x); //~ ERROR cannot assign
 }
diff --git a/src/test/compile-fail/unboxed-closure-region.rs b/src/test/compile-fail/unboxed-closure-region.rs
index 9d966798694..98ac54de8ad 100644
--- a/src/test/compile-fail/unboxed-closure-region.rs
+++ b/src/test/compile-fail/unboxed-closure-region.rs
@@ -15,6 +15,6 @@
 fn main() {
     let _f = {
         let x = 0us;
-        |:| x //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements
+        || x //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements
     };
 }
diff --git a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
index bb92e57d70c..0bdc261e8c8 100644
--- a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
+++ b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
@@ -15,6 +15,6 @@
 
 fn main() {
     let mut x = 0us;
-    let f = |:| x += 1;
+    let f = || x += 1;
     let _y = x; //~ ERROR cannot use `x` because it was mutably borrowed
 }
diff --git a/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs b/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs
index ef6c439aeb8..3dd5779914d 100644
--- a/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs
+++ b/src/test/compile-fail/unboxed-closures-infer-argument-types-two-region-pointers.rs
@@ -23,7 +23,7 @@ fn doit<T,F>(val: T, f: &F)
 }
 
 pub fn main() {
-    doit(0, &|&: x, y| {
+    doit(0, &|x, y| {
         x.set(y); //~ ERROR cannot infer
     });
 }
diff --git a/src/test/compile-fail/unboxed-closures-type-mismatch.rs b/src/test/compile-fail/unboxed-closures-type-mismatch.rs
index f7ac2274ffb..e1192b22485 100644
--- a/src/test/compile-fail/unboxed-closures-type-mismatch.rs
+++ b/src/test/compile-fail/unboxed-closures-type-mismatch.rs
@@ -13,7 +13,7 @@
 use std::ops::FnMut;
 
 pub fn main() {
-    let mut f = |&mut: x: isize, y: isize| -> isize { x + y };
+    let mut f = |x: isize, y: isize| -> isize { x + y };
     let z = f(1us, 2);    //~ ERROR mismatched types
     println!("{}", z);
 }
diff --git a/src/test/compile-fail/unused-mut-warning-captured-var.rs b/src/test/compile-fail/unused-mut-warning-captured-var.rs
index 87ea56c0553..d4dc58864ad 100644
--- a/src/test/compile-fail/unused-mut-warning-captured-var.rs
+++ b/src/test/compile-fail/unused-mut-warning-captured-var.rs
@@ -13,5 +13,5 @@
 fn main() {
     let mut x = 1;
     //~^ ERROR: variable does not need to be mutable
-    move|:| { println!("{}", x); };
+    move|| { println!("{}", x); };
 }
diff --git a/src/test/debuginfo/closure-in-generic-function.rs b/src/test/debuginfo/closure-in-generic-function.rs
index 59428a2c06f..ea684b1d69c 100644
--- a/src/test/debuginfo/closure-in-generic-function.rs
+++ b/src/test/debuginfo/closure-in-generic-function.rs
@@ -51,7 +51,7 @@
 
 fn some_generic_fun<T1, T2>(a: T1, b: T2) -> (T2, T1) {
 
-    let closure = |&: x, y| {
+    let closure = |x, y| {
         zzz(); // #break
         (y, x)
     };
diff --git a/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs b/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs
index 5e04c81cefd..fb4378d5e8b 100644
--- a/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs
+++ b/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs
@@ -18,7 +18,7 @@
 
 // Nothing to do here really, just make sure it compiles. See issue #8513.
 fn main() {
-    let _ = |&:|();
+    let _ = ||();
     let _ = (1u..3).map(|_| 5);
 }
 
diff --git a/src/test/debuginfo/lexical-scope-in-stack-closure.rs b/src/test/debuginfo/lexical-scope-in-stack-closure.rs
index f2d09221669..6cb1218c123 100644
--- a/src/test/debuginfo/lexical-scope-in-stack-closure.rs
+++ b/src/test/debuginfo/lexical-scope-in-stack-closure.rs
@@ -79,7 +79,7 @@ fn main() {
     zzz(); // #break
     sentinel();
 
-    let closure = |&: x: int| {
+    let closure = |x: int| {
         zzz(); // #break
         sentinel();
 
diff --git a/src/test/debuginfo/lexical-scope-in-unique-closure.rs b/src/test/debuginfo/lexical-scope-in-unique-closure.rs
index be4085b63ab..ba660deeca0 100644
--- a/src/test/debuginfo/lexical-scope-in-unique-closure.rs
+++ b/src/test/debuginfo/lexical-scope-in-unique-closure.rs
@@ -80,7 +80,7 @@ fn main() {
     zzz(); // #break
     sentinel();
 
-    let unique_closure = |: x:int| {
+    let unique_closure = |x:int| {
         zzz(); // #break
         sentinel();
 
diff --git a/src/test/debuginfo/multi-byte-chars.rs b/src/test/debuginfo/multi-byte-chars.rs
index cb7e26327c3..dd0d86bf742 100644
--- a/src/test/debuginfo/multi-byte-chars.rs
+++ b/src/test/debuginfo/multi-byte-chars.rs
@@ -24,5 +24,5 @@ struct C { θ: u8 }
 
 fn main() {
     let x =  C { θ: 0 };
-    (|&: c: C| c.θ )(x);
+    (|c: C| c.θ )(x);
 }
diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs
index 24b6df4e8f1..e41c69fa65d 100644
--- a/src/test/debuginfo/type-names.rs
+++ b/src/test/debuginfo/type-names.rs
@@ -322,8 +322,8 @@ fn main() {
     // how that maps to rustc's internal representation of these forms.
     // Once closures have reached their 1.0 form, the tests below should
     // probably be expanded.
-    let closure1 = (|&: x:isize| {}, 0u);
-    let closure2 = (|&: x:i8, y: f32| { (x as f32) + y }, 0u);
+    let closure1 = (|x:isize| {}, 0u);
+    let closure2 = (|x:i8, y: f32| { (x as f32) + y }, 0u);
 
     zzz(); // #break
 }
diff --git a/src/test/debuginfo/var-captured-in-nested-closure.rs b/src/test/debuginfo/var-captured-in-nested-closure.rs
index d7831c983c0..512df3605bf 100644
--- a/src/test/debuginfo/var-captured-in-nested-closure.rs
+++ b/src/test/debuginfo/var-captured-in-nested-closure.rs
@@ -101,10 +101,10 @@ fn main() {
     let struct_ref = &a_struct;
     let owned = box 6;
 
-    let mut closure = |&mut:| {
+    let mut closure = || {
         let closure_local = 8;
 
-        let mut nested_closure = |&mut:| {
+        let mut nested_closure = || {
             zzz(); // #break
             variable = constant + a_struct.a + struct_ref.a + *owned + closure_local;
         };
diff --git a/src/test/debuginfo/var-captured-in-sendable-closure.rs b/src/test/debuginfo/var-captured-in-sendable-closure.rs
index 30a07ea46dd..b07c8ffde7f 100644
--- a/src/test/debuginfo/var-captured-in-sendable-closure.rs
+++ b/src/test/debuginfo/var-captured-in-sendable-closure.rs
@@ -61,7 +61,7 @@ fn main() {
 
     let owned = box 5;
 
-    let closure = move |:| {
+    let closure = move || {
         zzz(); // #break
         do_something(&constant, &a_struct.a, &*owned);
     };
@@ -73,7 +73,7 @@ fn main() {
     // The `self` argument of the following closure should be passed by value
     // to FnOnce::call_once(self, args), which gets translated a bit differently
     // than the regular case. Let's make sure this is supported too.
-    let immedate_env = move |:| {
+    let immedate_env = move || {
         zzz(); // #break
         return constant2;
     };
diff --git a/src/test/debuginfo/var-captured-in-stack-closure.rs b/src/test/debuginfo/var-captured-in-stack-closure.rs
index 9daf6abba11..ee706c13634 100644
--- a/src/test/debuginfo/var-captured-in-stack-closure.rs
+++ b/src/test/debuginfo/var-captured-in-stack-closure.rs
@@ -94,7 +94,7 @@ fn main() {
     let owned = box 6;
 
     {
-        let mut first_closure = |&mut:| {
+        let mut first_closure = || {
             zzz(); // #break
             variable = constant + a_struct.a + struct_ref.a + *owned;
         };
@@ -103,7 +103,7 @@ fn main() {
     }
 
     {
-        let mut second_closure = |&mut:| {
+        let mut second_closure = || {
             zzz(); // #break
             variable = constant + a_struct.a + struct_ref.a + *owned;
         };
diff --git a/src/test/run-make/save-analysis/foo.rs b/src/test/run-make/save-analysis/foo.rs
index cb3b3d9af38..25f7c64b5ab 100644
--- a/src/test/run-make/save-analysis/foo.rs
+++ b/src/test/run-make/save-analysis/foo.rs
@@ -269,7 +269,7 @@ fn hello<X: SomeTrait>((z, a) : (u32, String), ex: X) {
     s4.provided_method();
     s2.prov(45);
 
-    let closure = |&: x: u32, s: &SomeTrait| {
+    let closure = |x: u32, s: &SomeTrait| {
         s.Method(23);
         return x + y;
     };
diff --git a/src/test/run-pass/block-fn-coerce.rs b/src/test/run-pass/block-fn-coerce.rs
index fe52b1a693c..f3c874a5afc 100644
--- a/src/test/run-pass/block-fn-coerce.rs
+++ b/src/test/run-pass/block-fn-coerce.rs
@@ -13,6 +13,6 @@ fn force<F>(f: F) -> int where F: FnOnce() -> int { return f(); }
 pub fn main() {
     fn f() -> int { return 7; }
     assert_eq!(force(f), 7);
-    let g = {|&:|force(f)};
+    let g = {||force(f)};
     assert_eq!(g(), 7);
 }
diff --git a/src/test/run-pass/borrowck-closures-two-imm.rs b/src/test/run-pass/borrowck-closures-two-imm.rs
index df8dbdd03c7..c907778339e 100644
--- a/src/test/run-pass/borrowck-closures-two-imm.rs
+++ b/src/test/run-pass/borrowck-closures-two-imm.rs
@@ -17,8 +17,8 @@
 fn a() -> i32 {
     let mut x = 3i32;
     x += 1;
-    let c1 = |&:| x * 4;
-    let c2 = |&:| x * 5;
+    let c1 = || x * 4;
+    let c2 = || x * 5;
     c1() * c2() * x
 }
 
@@ -29,16 +29,16 @@ fn get(x: &i32) -> i32 {
 fn b() -> i32 {
     let mut x = 3i32;
     x += 1;
-    let c1 = |&:| get(&x);
-    let c2 = |&:| get(&x);
+    let c1 = || get(&x);
+    let c2 = || get(&x);
     c1() * c2() * x
 }
 
 fn c() -> i32 {
     let mut x = 3i32;
     x += 1;
-    let c1 = |&:| x * 5;
-    let c2 = |&:| get(&x);
+    let c1 = || x * 5;
+    let c2 = || get(&x);
     c1() * c2() * x
 }
 
diff --git a/src/test/run-pass/borrowck-move-by-capture-ok.rs b/src/test/run-pass/borrowck-move-by-capture-ok.rs
index 773780ffb09..1be57674fa1 100644
--- a/src/test/run-pass/borrowck-move-by-capture-ok.rs
+++ b/src/test/run-pass/borrowck-move-by-capture-ok.rs
@@ -14,7 +14,7 @@
 
 pub fn main() {
     let bar = box 3;
-    let h = |:| -> int *bar;
+    let h = || -> int *bar;
     assert_eq!(h(), 3);
 }
 
diff --git a/src/test/run-pass/capture-clauses-unboxed-closures.rs b/src/test/run-pass/capture-clauses-unboxed-closures.rs
index de1196e10d8..ca315b7a9f1 100644
--- a/src/test/run-pass/capture-clauses-unboxed-closures.rs
+++ b/src/test/run-pass/capture-clauses-unboxed-closures.rs
@@ -19,6 +19,6 @@ fn each<'a,T,F:FnMut(&'a T)>(x: &'a [T], mut f: F) {
 fn main() {
     let mut sum = 0u;
     let elems = [ 1u, 2, 3, 4, 5 ];
-    each(&elems, |&mut: val: &uint| sum += *val);
+    each(&elems, |val: &uint| sum += *val);
     assert_eq!(sum, 15);
 }
diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs
index c0877568b72..fa16ea00145 100644
--- a/src/test/run-pass/closure-inference2.rs
+++ b/src/test/run-pass/closure-inference2.rs
@@ -11,7 +11,7 @@
 // Test a rather underspecified example:
 
 pub fn main() {
-    let f = {|&: i| i};
+    let f = {|i| i};
     assert_eq!(f(2), 2);
     assert_eq!(f(5), 5);
 }
diff --git a/src/test/run-pass/empty-tag.rs b/src/test/run-pass/empty-tag.rs
index 65575945945..95af729e5e1 100644
--- a/src/test/run-pass/empty-tag.rs
+++ b/src/test/run-pass/empty-tag.rs
@@ -23,6 +23,6 @@ fn wrapper3(i: chan) {
 }
 
 pub fn main() {
-    let wrapped = {|&:|wrapper3(chan::chan_t)};
+    let wrapped = {||wrapper3(chan::chan_t)};
     wrapped();
 }
diff --git a/src/test/run-pass/fn-pattern-expected-type.rs b/src/test/run-pass/fn-pattern-expected-type.rs
index 24bf1f94d88..3e81ca5125b 100644
--- a/src/test/run-pass/fn-pattern-expected-type.rs
+++ b/src/test/run-pass/fn-pattern-expected-type.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let f = |&: (x, y): (int, int)| {
+    let f = |(x, y): (int, int)| {
         assert_eq!(x, 1);
         assert_eq!(y, 2);
     };
diff --git a/src/test/run-pass/fn-type-infer.rs b/src/test/run-pass/fn-type-infer.rs
index 785abbe449b..34417891197 100644
--- a/src/test/run-pass/fn-type-infer.rs
+++ b/src/test/run-pass/fn-type-infer.rs
@@ -12,7 +12,7 @@
 
 pub fn main() {
     // We should be able to type infer inside of ||s.
-    let _f = |&:| {
+    let _f = || {
         let i = 10;
     };
 }
diff --git a/src/test/run-pass/hrtb-precedence-of-plus.rs b/src/test/run-pass/hrtb-precedence-of-plus.rs
index 1d1e744ef08..b59e7b67d4e 100644
--- a/src/test/run-pass/hrtb-precedence-of-plus.rs
+++ b/src/test/run-pass/hrtb-precedence-of-plus.rs
@@ -17,7 +17,7 @@
 // cause a compilation error. Issue #18772.
 
 fn adder(y: int) -> Box<Fn(int) -> int + 'static> {
-    box move |&: x| y + x
+    box move |x| y + x
 }
 
 fn main() {}
diff --git a/src/test/run-pass/hrtb-unboxed-closure-trait.rs b/src/test/run-pass/hrtb-unboxed-closure-trait.rs
index fea628177da..c34e1a4862f 100644
--- a/src/test/run-pass/hrtb-unboxed-closure-trait.rs
+++ b/src/test/run-pass/hrtb-unboxed-closure-trait.rs
@@ -18,5 +18,5 @@ fn foo<F:Fn(&int)>(f: F) {
 }
 
 fn main() {
-    foo(|&: x: &int| println!("{}", *x));
+    foo(|x: &int| println!("{}", *x));
 }
diff --git a/src/test/run-pass/issue-10718.rs b/src/test/run-pass/issue-10718.rs
index 71b4cbe9334..c3ec3fc40e3 100644
--- a/src/test/run-pass/issue-10718.rs
+++ b/src/test/run-pass/issue-10718.rs
@@ -15,6 +15,6 @@ fn f<F:FnOnce()>(p: F) {
 }
 
 pub fn main() {
-    let p = |:| ();
+    let p = || ();
     f(p);
 }
diff --git a/src/test/run-pass/issue-13434.rs b/src/test/run-pass/issue-13434.rs
index 95370144125..5d7a84d80d4 100644
--- a/src/test/run-pass/issue-13434.rs
+++ b/src/test/run-pass/issue-13434.rs
@@ -26,5 +26,5 @@ fn do_stuff<R: Repro>(r: R) -> String {
 }
 
 pub fn main() {
-  assert_eq!("MyStruct".to_string(), do_stuff(|: s: MyStruct| format!("{:?}", s)));
+  assert_eq!("MyStruct".to_string(), do_stuff(|s: MyStruct| format!("{:?}", s)));
 }
diff --git a/src/test/run-pass/issue-1460.rs b/src/test/run-pass/issue-1460.rs
index e7516639db0..44465fe5f80 100644
--- a/src/test/run-pass/issue-1460.rs
+++ b/src/test/run-pass/issue-1460.rs
@@ -10,5 +10,5 @@
 
 
 pub fn main() {
-    {|&: i| if 1 == i { }};
+    {|i| if 1 == i { }};
 }
diff --git a/src/test/run-pass/issue-14919.rs b/src/test/run-pass/issue-14919.rs
index 4d05b98147b..933e7e40f06 100644
--- a/src/test/run-pass/issue-14919.rs
+++ b/src/test/run-pass/issue-14919.rs
@@ -58,6 +58,6 @@ fn match_indices<'a, M, T: IntoMatcher<'a, M>>(s: &'a str, from: T) -> MatchIndi
 
 fn main() {
     let s = "abcbdef";
-    match_indices(s, |&mut: c: char| c == 'b')
+    match_indices(s, |c: char| c == 'b')
         .collect::<Vec<(uint, uint)>>();
 }
diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs
index 7d53b672951..ab9554f65d4 100644
--- a/src/test/run-pass/issue-15571.rs
+++ b/src/test/run-pass/issue-15571.rs
@@ -48,7 +48,7 @@ fn match_on_binding() {
 
 fn match_on_upvar() {
     let mut foo = Some(box 8i32);
-    let f = move|:| {
+    let f = move|| {
         match foo {
             None => {},
             Some(x) => {
diff --git a/src/test/run-pass/issue-16256.rs b/src/test/run-pass/issue-16256.rs
index e7422e233a6..48ea3a93296 100644
--- a/src/test/run-pass/issue-16256.rs
+++ b/src/test/run-pass/issue-16256.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     let mut buf = Vec::new();
-    |&mut: c: u8| buf.push(c);
+    |c: u8| buf.push(c);
 }
diff --git a/src/test/run-pass/issue-16560.rs b/src/test/run-pass/issue-16560.rs
index 6b03a499f15..ca40b2fe4c7 100644
--- a/src/test/run-pass/issue-16560.rs
+++ b/src/test/run-pass/issue-16560.rs
@@ -15,7 +15,7 @@ use std::mem;
 
 fn main() {
     let y = 0u8;
-    let closure = move |&: x| y + x;
+    let closure = move |x| y + x;
 
     // Check that both closures are capturing by value
     assert_eq!(1, mem::size_of_val(&closure));
diff --git a/src/test/run-pass/issue-16668.rs b/src/test/run-pass/issue-16668.rs
index 95b7728b47f..daf09047bef 100644
--- a/src/test/run-pass/issue-16668.rs
+++ b/src/test/run-pass/issue-16668.rs
@@ -21,7 +21,7 @@ struct Parser<'a, I, O> {
 impl<'a, I: 'a, O: 'a> Parser<'a, I, O> {
     fn compose<K: 'a>(mut self, mut rhs: Parser<'a, O, K>) -> Parser<'a, I, K> {
         Parser {
-            parse: box move |&mut: x: I| {
+            parse: box move |x: I| {
                 match (self.parse)(x) {
                     Ok(r) => (rhs.parse)(r),
                     Err(e) => Err(e)
diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs
index d426f82f89f..cc427dd941b 100644
--- a/src/test/run-pass/issue-16774.rs
+++ b/src/test/run-pass/issue-16774.rs
@@ -47,7 +47,7 @@ fn main() {
     {
         let mut test = X(box 5);
         {
-            let mut change = |&mut:| { *test = 10 };
+            let mut change = || { *test = 10 };
             change();
         }
         assert_eq!(*test, 10);
diff --git a/src/test/run-pass/issue-17816.rs b/src/test/run-pass/issue-17816.rs
index d9d2c771390..f8fbd680dcb 100644
--- a/src/test/run-pass/issue-17816.rs
+++ b/src/test/run-pass/issue-17816.rs
@@ -12,7 +12,7 @@
 
 fn main() {
     struct Symbol<'a, F: Fn(Vec<&'a str>) -> &'a str> { function: F }
-    let f = |&: x: Vec<&str>| -> &str "foobar";
+    let f = |x: Vec<&str>| -> &str "foobar";
     let sym = Symbol { function: f };
     (sym.function)(vec![]);
 }
diff --git a/src/test/run-pass/issue-17897.rs b/src/test/run-pass/issue-17897.rs
index da6c83142ea..3774aaa1903 100644
--- a/src/test/run-pass/issue-17897.rs
+++ b/src/test/run-pass/issue-17897.rs
@@ -17,5 +17,5 @@ fn action(cb: Thunk<uint, uint>) -> uint {
 }
 
 pub fn main() {
-    println!("num: {}", action(Thunk::with_arg(move |:u| u)));
+    println!("num: {}", action(Thunk::with_arg(move |u| u)));
 }
diff --git a/src/test/run-pass/issue-18188.rs b/src/test/run-pass/issue-18188.rs
index a2152db6884..7a5a86822af 100644
--- a/src/test/run-pass/issue-18188.rs
+++ b/src/test/run-pass/issue-18188.rs
@@ -20,7 +20,7 @@ pub fn propagate<T, E, F, G>(action: F) -> Thunk<Result<T, E>, Result<T, E>>
         E: Promisable + Clone,
         F: FnOnce(&T) -> Result<T, E> + Send,
         G: FnOnce(Result<T, E>) -> Result<T, E> {
-    Thunk::with_arg(move |: result: Result<T, E>| {
+    Thunk::with_arg(move |result: Result<T, E>| {
         match result {
             Ok(ref t) => action(t),
             Err(ref e) => Err(e.clone()),
diff --git a/src/test/run-pass/issue-18652.rs b/src/test/run-pass/issue-18652.rs
index ef2c15c748c..8f560258d9f 100644
--- a/src/test/run-pass/issue-18652.rs
+++ b/src/test/run-pass/issue-18652.rs
@@ -17,5 +17,5 @@
 fn main() {
     let x = 2u8;
     let y = 3u8;
-    assert_eq!((move |:| x + y)(), 5);
+    assert_eq!((move || x + y)(), 5);
 }
diff --git a/src/test/run-pass/issue-18661.rs b/src/test/run-pass/issue-18661.rs
index 6a2f73a787a..bb2907241c2 100644
--- a/src/test/run-pass/issue-18661.rs
+++ b/src/test/run-pass/issue-18661.rs
@@ -20,7 +20,7 @@ pub fn inside<F: Fn()>(c: F) {
 // Use different number of type parameters and closure type to trigger
 // an obvious ICE when param environments are mixed up
 pub fn outside<A,B>() {
-    inside(|&:| {});
+    inside(|| {});
 }
 
 fn main() {
diff --git a/src/test/run-pass/issue-18685.rs b/src/test/run-pass/issue-18685.rs
index be6dd583132..698b61e5759 100644
--- a/src/test/run-pass/issue-18685.rs
+++ b/src/test/run-pass/issue-18685.rs
@@ -17,7 +17,7 @@ trait Tr {
     fn foo(&self);
 
     fn bar(&self) {
-        (|:| { self.foo() })()
+        (|| { self.foo() })()
     }
 }
 
diff --git a/src/test/run-pass/issue-18711.rs b/src/test/run-pass/issue-18711.rs
index 6a04e68af0c..0338a4eff22 100644
--- a/src/test/run-pass/issue-18711.rs
+++ b/src/test/run-pass/issue-18711.rs
@@ -17,5 +17,5 @@
 extern crate "issue-18711" as issue;
 
 fn main() {
-    (|:| issue::inner(()))();
+    (|| issue::inner(()))();
 }
diff --git a/src/test/run-pass/issue-19135.rs b/src/test/run-pass/issue-19135.rs
index 9557d7e4fa8..031a63ba474 100644
--- a/src/test/run-pass/issue-19135.rs
+++ b/src/test/run-pass/issue-19135.rs
@@ -14,7 +14,7 @@
 struct LifetimeStruct<'a>;
 
 fn main() {
-    takes_hrtb_closure(|&mut: lts| println!("{:?}", lts));
+    takes_hrtb_closure(|lts| println!("{:?}", lts));
 }
 
 fn takes_hrtb_closure<F: for<'a>FnMut(LifetimeStruct<'a>)>(mut f: F) {
diff --git a/src/test/run-pass/issue-2074.rs b/src/test/run-pass/issue-2074.rs
index 120ada96c15..5f2805ed354 100644
--- a/src/test/run-pass/issue-2074.rs
+++ b/src/test/run-pass/issue-2074.rs
@@ -11,11 +11,11 @@
 #![allow(non_camel_case_types)]
 
 pub fn main() {
-    let one = |&:| {
+    let one = || {
         enum r { a };
         r::a as uint
     };
-    let two = |&:| {
+    let two = || {
         enum r { a };
         r::a as uint
     };
diff --git a/src/test/run-pass/issue-21306.rs b/src/test/run-pass/issue-21306.rs
index c75abd88963..ca2a4e546b7 100644
--- a/src/test/run-pass/issue-21306.rs
+++ b/src/test/run-pass/issue-21306.rs
@@ -12,6 +12,6 @@ use std::sync::Arc;
 
 fn main() {
     let x = 5us;
-    let command = Arc::new(Box::new(|&:| { x*2 }));
+    let command = Arc::new(Box::new(|| { x*2 }));
     assert_eq!(command(), 10);
 }
diff --git a/src/test/run-pass/issue-3052.rs b/src/test/run-pass/issue-3052.rs
index c08bdf54408..3e7deee6ec1 100644
--- a/src/test/run-pass/issue-3052.rs
+++ b/src/test/run-pass/issue-3052.rs
@@ -14,7 +14,7 @@
 type Connection = Box<FnMut(Vec<u8>) + 'static>;
 
 fn f() -> Option<Connection> {
-    let mock_connection: Connection = box |&mut: _| {};
+    let mock_connection: Connection = box |_| {};
     Some(mock_connection)
 }
 
diff --git a/src/test/run-pass/issue-3429.rs b/src/test/run-pass/issue-3429.rs
index 60c53450004..6fc8c9c6843 100644
--- a/src/test/run-pass/issue-3429.rs
+++ b/src/test/run-pass/issue-3429.rs
@@ -10,6 +10,6 @@
 
 pub fn main() {
   let x = 1u;
-  let y = |&:| x;
+  let y = || x;
   let _z = y();
 }
diff --git a/src/test/run-pass/issue-5239-2.rs b/src/test/run-pass/issue-5239-2.rs
index 69255c57681..dd9a6fb3543 100644
--- a/src/test/run-pass/issue-5239-2.rs
+++ b/src/test/run-pass/issue-5239-2.rs
@@ -11,7 +11,7 @@
 // Regression test for issue #5239
 
 pub fn main() {
-    let _f = |&: ref x: int| { *x };
+    let _f = |ref x: int| { *x };
     let foo = 10;
     assert!(_f(foo) == 10);
 }
diff --git a/src/test/run-pass/issue-6157.rs b/src/test/run-pass/issue-6157.rs
index 07c7c6888e1..39f387afaba 100644
--- a/src/test/run-pass/issue-6157.rs
+++ b/src/test/run-pass/issue-6157.rs
@@ -21,7 +21,7 @@ fn squarei<'a>(x: int, op: &'a mut OpInt) -> int { op.call(x, x) }
 fn muli(x:int, y:int) -> int { x * y }
 
 pub fn main() {
-    let mut f = |&mut: x, y| muli(x, y);
+    let mut f = |x, y| muli(x, y);
     {
         let g = &mut f;
         let h = g as &mut OpInt;
diff --git a/src/test/run-pass/issue-868.rs b/src/test/run-pass/issue-868.rs
index b2ccc092358..e47999fc468 100644
--- a/src/test/run-pass/issue-868.rs
+++ b/src/test/run-pass/issue-868.rs
@@ -20,5 +20,5 @@ pub fn main() {
     let _: () = f(| | { });
     // empty block with no type info should compile too
     let _ = f(||{});
-    let _ = (|&:|{});
+    let _ = (||{});
 }
diff --git a/src/test/run-pass/issue-9129.rs b/src/test/run-pass/issue-9129.rs
index 2ef1c1d264a..6c843993040 100644
--- a/src/test/run-pass/issue-9129.rs
+++ b/src/test/run-pass/issue-9129.rs
@@ -29,7 +29,7 @@ fn Ident_new() -> Ident {
 
 pub fn light_fuse(fld: Box<bomb>) {
     int3!();
-    let f = |&:| {
+    let f = || {
         int3!();
         fld.boom(Ident_new()); // *** 1
     };
diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs
index b33e6512b18..009dc562d56 100644
--- a/src/test/run-pass/lambda-infer-unresolved.rs
+++ b/src/test/run-pass/lambda-infer-unresolved.rs
@@ -16,7 +16,7 @@ struct Refs { refs: Vec<int> , n: int }
 
 pub fn main() {
     let mut e = Refs{refs: vec!(), n: 0};
-    let _f = |&:| println!("{}", e.n);
+    let _f = || println!("{}", e.n);
     let x: &[int] = e.refs.as_slice();
     assert_eq!(x.len(), 0);
 }
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index 0cd8c13a4e1..4231e5dba9f 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -19,7 +19,8 @@ struct A { a: Box<isize> }
 fn foo() -> Box<FnMut() -> isize + 'static> {
     let k = box 22;
     let _u = A {a: k.clone()};
-    let result  = |&mut:| 22;
+    // FIXME(#16640) suffix in `22i` suffix shouldn't be necessary
+    let result  = || 22i;
     box result
 }
 
diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs
index 388b814b2af..b1f7da17c8f 100644
--- a/src/test/run-pass/mut-function-arguments.rs
+++ b/src/test/run-pass/mut-function-arguments.rs
@@ -17,7 +17,7 @@ fn f(mut y: Box<int>) {
 }
 
 fn g() {
-    let frob = |&: mut q: Box<int>| { *q = 2; assert!(*q == 2); };
+    let frob = |mut q: Box<int>| { *q = 2; assert!(*q == 2); };
     let w = box 37;
     frob(w);
 
diff --git a/src/test/run-pass/mut-in-ident-patterns.rs b/src/test/run-pass/mut-in-ident-patterns.rs
index 8be200d3bf3..d3ae80861f2 100644
--- a/src/test/run-pass/mut-in-ident-patterns.rs
+++ b/src/test/run-pass/mut-in-ident-patterns.rs
@@ -75,6 +75,6 @@ pub fn main() {
     x = 30;
     assert_eq!(x, 30);
 
-    (|&: A { x: mut t }: A| { t = t+1; t })(A { x: 34 });
+    (|A { x: mut t }: A| { t = t+1; t })(A { x: 34 });
 
 }
diff --git a/src/test/run-pass/pattern-in-closure.rs b/src/test/run-pass/pattern-in-closure.rs
index c718b948f8d..e4f1df2d637 100644
--- a/src/test/run-pass/pattern-in-closure.rs
+++ b/src/test/run-pass/pattern-in-closure.rs
@@ -14,8 +14,8 @@ struct Foo {
 }
 
 pub fn main() {
-    let f = |&: (x, _): (int, int)| println!("{}", x + 1);
-    let g = |&: Foo { x: x, y: _y }: Foo| println!("{}", x + 1);
+    let f = |(x, _): (int, int)| println!("{}", x + 1);
+    let g = |Foo { x: x, y: _y }: Foo| println!("{}", x + 1);
     f((2, 3));
     g(Foo { x: 1, y: 2 });
 }
diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs
index dc6f377e9b2..6ebef9f34ad 100644
--- a/src/test/run-pass/regions-copy-closure.rs
+++ b/src/test/run-pass/regions-copy-closure.rs
@@ -24,7 +24,7 @@ pub fn main() {
     let mut i = 3i32;
     assert_eq!(i, 3);
     {
-        let cl = |&mut:| i += 1;
+        let cl = || i += 1;
         let mut cl_box = box_it(box cl);
         cl_box.cl.call_mut(());
     }
diff --git a/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs b/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs
index c4852c9162c..a2b6d569ac9 100644
--- a/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs
+++ b/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs
@@ -28,14 +28,14 @@
 pub fn main() {
     fn explicit() {
         fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box<for<'a> FnMut(&'a int)>) {}
-        test(Some(box |&mut: _f: Box<for<'a> FnMut(&'a int)>| {}));
+        test(Some(box |_f: Box<for<'a> FnMut(&'a int)>| {}));
     }
 
     // The code below is shorthand for the code above (and more likely
     // to represent what one encounters in practice).
     fn implicit() {
         fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box<        FnMut(&   int)>) {}
-        test(Some(box |&mut: _f: Box<        FnMut(&   int)>| {}));
+        test(Some(box |_f: Box<        FnMut(&   int)>| {}));
     }
 
     explicit();
diff --git a/src/test/run-pass/regions-static-closure.rs b/src/test/run-pass/regions-static-closure.rs
index abd5789bb1f..7198c35944f 100644
--- a/src/test/run-pass/regions-static-closure.rs
+++ b/src/test/run-pass/regions-static-closure.rs
@@ -25,6 +25,6 @@ fn call_static_closure(mut cl: closure_box<'static>) {
 }
 
 pub fn main() {
-    let cl_box = box_it(box |&mut:| println!("Hello, world!"));
+    let cl_box = box_it(box || println!("Hello, world!"));
     call_static_closure(cl_box);
 }
diff --git a/src/test/run-pass/return-from-closure.rs b/src/test/run-pass/return-from-closure.rs
index 899dc8ddbe9..60856ee6042 100644
--- a/src/test/run-pass/return-from-closure.rs
+++ b/src/test/run-pass/return-from-closure.rs
@@ -13,7 +13,7 @@
 static mut calls: uint = 0;
 
 fn surrounding() {
-    let return_works = |&: n: int| {
+    let return_works = |n: int| {
         unsafe { calls += 1 }
 
         if n >= 0 { return; }
@@ -23,7 +23,7 @@ fn surrounding() {
     return_works(10);
     return_works(20);
 
-    let return_works_proc = |: n: int| {
+    let return_works_proc = |n: int| {
         unsafe { calls += 1 }
 
         if n >= 0 { return; }
diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
index 89624c3ac16..6c9707103b9 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -21,7 +21,7 @@ fn test05_start<F:FnOnce(int)>(f: F) {
 
 fn test05() {
     let three = box 3;
-    let fn_to_send = move|: n:int| {
+    let fn_to_send = move|n:int| {
         println!("{}", *three + n); // will copy x into the closure
         assert_eq!(*three, 3);
     };
diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs
index 6695920723a..4df1ff14810 100644
--- a/src/test/run-pass/tempfile.rs
+++ b/src/test/run-pass/tempfile.rs
@@ -37,7 +37,7 @@ fn test_tempdir() {
 
 fn test_rm_tempdir() {
     let (tx, rx) = channel();
-    let f = move|:| -> () {
+    let f = move|| -> () {
         let tmp = TempDir::new("test_rm_tempdir").unwrap();
         tx.send(tmp.path().clone()).unwrap();
         panic!("panic to unwind past `tmp`");
@@ -48,7 +48,7 @@ fn test_rm_tempdir() {
 
     let tmp = TempDir::new("test_rm_tempdir").unwrap();
     let path = tmp.path().clone();
-    let f = move|:| -> () {
+    let f = move|| -> () {
         let _tmp = tmp;
         panic!("panic to unwind past `tmp`");
     };
@@ -57,10 +57,11 @@ fn test_rm_tempdir() {
 
     let path;
     {
-        let f = move|:| {
+        let f = move || {
             TempDir::new("test_rm_tempdir").unwrap()
         };
-        let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
+        // FIXME(#16640) `: TempDir` annotation shouldn't be necessary
+        let tmp: TempDir = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
         path = tmp.path().clone();
         assert!(path.exists());
     }
@@ -78,7 +79,7 @@ fn test_rm_tempdir() {
 
 fn test_rm_tempdir_close() {
     let (tx, rx) = channel();
-    let f = move|:| -> () {
+    let f = move|| -> () {
         let tmp = TempDir::new("test_rm_tempdir").unwrap();
         tx.send(tmp.path().clone()).unwrap();
         tmp.close();
@@ -90,7 +91,7 @@ fn test_rm_tempdir_close() {
 
     let tmp = TempDir::new("test_rm_tempdir").unwrap();
     let path = tmp.path().clone();
-    let f = move|:| -> () {
+    let f = move|| -> () {
         let tmp = tmp;
         tmp.close();
         panic!("panic when unwinding past `tmp`");
@@ -100,10 +101,11 @@ fn test_rm_tempdir_close() {
 
     let path;
     {
-        let f = move|:| {
+        let f = move || {
             TempDir::new("test_rm_tempdir").unwrap()
         };
-        let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
+        // FIXME(#16640) `: TempDir` annotation shouldn't be necessary
+        let tmp: TempDir = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
         path = tmp.path().clone();
         assert!(path.exists());
         tmp.close();
diff --git a/src/test/run-pass/type-id-higher-rank.rs b/src/test/run-pass/type-id-higher-rank.rs
index b114391a36d..d33ebeadba8 100644
--- a/src/test/run-pass/type-id-higher-rank.rs
+++ b/src/test/run-pass/type-id-higher-rank.rs
@@ -56,8 +56,8 @@ fn main() {
     // Note that every unboxed closure has its own anonymous type,
     // so no two IDs should equal each other, even when compatible
     {
-        let a = id(|&: _: &int, _: &int| {});
-        let b = id(|&: _: &int, _: &int| {});
+        let a = id(|_: &int, _: &int| {});
+        let b = id(|_: &int, _: &int| {});
         assert!(a != b);
     }
 
diff --git a/src/test/run-pass/unboxed-closures-all-traits.rs b/src/test/run-pass/unboxed-closures-all-traits.rs
index 635e1670aad..7e71e1da462 100644
--- a/src/test/run-pass/unboxed-closures-all-traits.rs
+++ b/src/test/run-pass/unboxed-closures-all-traits.rs
@@ -24,8 +24,8 @@ fn c<F:FnOnce(int, int) -> int>(f: F) -> int {
 
 fn main() {
     let z: int = 7;
-    assert_eq!(a(move |&: x: int, y| x + y + z), 10);
-    assert_eq!(b(move |&mut: x: int, y| x + y + z), 14);
-    assert_eq!(c(move |: x: int, y| x + y + z), 18);
+    assert_eq!(a(move |x: int, y| x + y + z), 10);
+    assert_eq!(b(move |x: int, y| x + y + z), 14);
+    assert_eq!(c(move |x: int, y| x + y + z), 18);
 }
 
diff --git a/src/test/run-pass/unboxed-closures-boxed.rs b/src/test/run-pass/unboxed-closures-boxed.rs
index 27528ca5d56..d515ccf2ec0 100644
--- a/src/test/run-pass/unboxed-closures-boxed.rs
+++ b/src/test/run-pass/unboxed-closures-boxed.rs
@@ -15,7 +15,7 @@
 use std::ops::FnMut;
 
  fn make_adder(x: i32) -> Box<FnMut(i32)->i32+'static> {
-    (box move |&mut: y: i32| -> i32 { x + y }) as
+    (box move |y: i32| -> i32 { x + y }) as
         Box<FnMut(i32)->i32+'static>
 }
 
diff --git a/src/test/run-pass/unboxed-closures-by-ref.rs b/src/test/run-pass/unboxed-closures-by-ref.rs
index be955486dac..f1435b43f80 100644
--- a/src/test/run-pass/unboxed-closures-by-ref.rs
+++ b/src/test/run-pass/unboxed-closures-by-ref.rs
@@ -28,8 +28,8 @@ fn main() {
     let mut x = 0u;
     let y = 2u;
 
-    call_fn(|&:| assert_eq!(x, 0));
-    call_fn_mut(|&mut:| x += y);
-    call_fn_once(|:| x += y);
+    call_fn(|| assert_eq!(x, 0));
+    call_fn_mut(|| x += y);
+    call_fn_once(|| x += y);
     assert_eq!(x, y * 2);
 }
diff --git a/src/test/run-pass/unboxed-closures-direct-sugary-call.rs b/src/test/run-pass/unboxed-closures-direct-sugary-call.rs
index 2854d64f663..0c49c815170 100644
--- a/src/test/run-pass/unboxed-closures-direct-sugary-call.rs
+++ b/src/test/run-pass/unboxed-closures-direct-sugary-call.rs
@@ -11,7 +11,7 @@
 #![feature(unboxed_closures)]
 
 fn main() {
-    let mut unboxed = |&mut:| {};
+    let mut unboxed = || {};
     unboxed();
 }
 
diff --git a/src/test/run-pass/unboxed-closures-drop.rs b/src/test/run-pass/unboxed-closures-drop.rs
index 8d4d7b4ecb5..f4a24c17e6e 100644
--- a/src/test/run-pass/unboxed-closures-drop.rs
+++ b/src/test/run-pass/unboxed-closures-drop.rs
@@ -55,13 +55,13 @@ fn c<F:FnOnce(int, int) -> int>(f: F) -> int {
 
 fn test_fn() {
     {
-        a(move |&: a: int, b| { a + b });
+        a(move |a: int, b| { a + b });
     }
     assert_eq!(drop_count(), 0);
 
     {
         let z = &Droppable::new();
-        a(move |&: a: int, b| { z; a + b });
+        a(move |a: int, b| { z; a + b });
         assert_eq!(drop_count(), 0);
     }
     assert_eq!(drop_count(), 1);
@@ -69,7 +69,7 @@ fn test_fn() {
     {
         let z = &Droppable::new();
         let zz = &Droppable::new();
-        a(move |&: a: int, b| { z; zz; a + b });
+        a(move |a: int, b| { z; zz; a + b });
         assert_eq!(drop_count(), 1);
     }
     assert_eq!(drop_count(), 3);
@@ -77,13 +77,13 @@ fn test_fn() {
 
 fn test_fn_mut() {
     {
-        b(move |&mut: a: int, b| { a + b });
+        b(move |a: int, b| { a + b });
     }
     assert_eq!(drop_count(), 3);
 
     {
         let z = &Droppable::new();
-        b(move |&mut: a: int, b| { z; a + b });
+        b(move |a: int, b| { z; a + b });
         assert_eq!(drop_count(), 3);
     }
     assert_eq!(drop_count(), 4);
@@ -91,7 +91,7 @@ fn test_fn_mut() {
     {
         let z = &Droppable::new();
         let zz = &Droppable::new();
-        b(move |&mut: a: int, b| { z; zz; a + b });
+        b(move |a: int, b| { z; zz; a + b });
         assert_eq!(drop_count(), 4);
     }
     assert_eq!(drop_count(), 6);
@@ -99,13 +99,13 @@ fn test_fn_mut() {
 
 fn test_fn_once() {
     {
-        c(move |: a: int, b| { a + b });
+        c(move |a: int, b| { a + b });
     }
     assert_eq!(drop_count(), 6);
 
     {
         let z = Droppable::new();
-        c(move |: a: int, b| { z; a + b });
+        c(move |a: int, b| { z; a + b });
         assert_eq!(drop_count(), 7);
     }
     assert_eq!(drop_count(), 7);
@@ -113,7 +113,7 @@ fn test_fn_once() {
     {
         let z = Droppable::new();
         let zz = Droppable::new();
-        c(move |: a: int, b| { z; zz; a + b });
+        c(move |a: int, b| { z; zz; a + b });
         assert_eq!(drop_count(), 9);
     }
     assert_eq!(drop_count(), 9);
diff --git a/src/test/run-pass/unboxed-closures-generic.rs b/src/test/run-pass/unboxed-closures-generic.rs
index 04c124946c9..f4af42a866b 100644
--- a/src/test/run-pass/unboxed-closures-generic.rs
+++ b/src/test/run-pass/unboxed-closures-generic.rs
@@ -17,7 +17,7 @@ fn call_it<F:FnMut(i32,i32)->i32>(y: i32, mut f: F) -> i32 {
 }
 
 pub fn main() {
-    let f = |&mut: x: i32, y: i32| -> i32 { x + y };
+    let f = |x: i32, y: i32| -> i32 { x + y };
     let z = call_it(3, f);
     println!("{}", z);
     assert_eq!(z, 5);
diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs
index 5bebc70ca54..56de1596110 100644
--- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs
+++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs
@@ -22,5 +22,5 @@ fn doit<T,F>(val: T, f: &F)
 }
 
 pub fn main() {
-    doit(0, &|&: x /*: int*/ | { x.to_int(); });
+    doit(0, &|x /*: int*/ | { x.to_int(); });
 }
diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs
index a678c7a852f..c74ed665e7a 100644
--- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs
+++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs
@@ -18,5 +18,5 @@ use std::num::ToPrimitive;
 fn doit<T>(val: T, f: &Fn(T)) { f.call((val,)) }
 
 pub fn main() {
-    doit(0, &|&: x /*: int*/ | { x.to_int(); });
+    doit(0, &|x /*: int*/ | { x.to_int(); });
 }
diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs
index 6e0b3625a2e..a61dd095a0d 100644
--- a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs
+++ b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs
@@ -22,5 +22,5 @@ fn doit<T,F>(val: T, f: &F)
 }
 
 pub fn main() {
-    doit(0, &|&: x /*: int*/ | { x.to_int(); });
+    doit(0, &|x /*: int*/ | { x.to_int(); });
 }
diff --git a/src/test/run-pass/unboxed-closures-monomorphization.rs b/src/test/run-pass/unboxed-closures-monomorphization.rs
index 29064f48053..535c4562362 100644
--- a/src/test/run-pass/unboxed-closures-monomorphization.rs
+++ b/src/test/run-pass/unboxed-closures-monomorphization.rs
@@ -17,7 +17,7 @@
 
 fn main(){
     fn bar<'a, T:Clone+'a> (t: T) -> Box<FnMut()->T + 'a> {
-        box move |&mut:| t.clone()
+        box move || t.clone()
     }
 
     let mut f = bar(42_u32);
diff --git a/src/test/run-pass/unboxed-closures-move-mutable.rs b/src/test/run-pass/unboxed-closures-move-mutable.rs
index 43a44eca2d0..0d04aee2a15 100644
--- a/src/test/run-pass/unboxed-closures-move-mutable.rs
+++ b/src/test/run-pass/unboxed-closures-move-mutable.rs
@@ -21,18 +21,18 @@ fn set(x: &mut uint) { *x = 42; }
 fn main() {
     {
         let mut x = 0u;
-        move |&mut:| x += 1;
+        move || x += 1;
     }
     {
         let mut x = 0u;
-        move |:| x += 1;
+        move || x += 1;
     }
     {
         let mut x = 0u;
-        move |&mut:| set(&mut x);
+        move || set(&mut x);
     }
     {
         let mut x = 0u;
-        move |:| set(&mut x);
+        move || set(&mut x);
     }
 }
diff --git a/src/test/run-pass/unboxed-closures-prelude.rs b/src/test/run-pass/unboxed-closures-prelude.rs
index f9fc5770a38..c8f0d5fde45 100644
--- a/src/test/run-pass/unboxed-closures-prelude.rs
+++ b/src/test/run-pass/unboxed-closures-prelude.rs
@@ -15,13 +15,13 @@
 #![feature(unboxed_closures)]
 
 fn main() {
-    let task: Box<Fn(int) -> int> = box |&: x| x;
+    let task: Box<Fn(int) -> int> = box |x| x;
     task.call((0, ));
 
-    let mut task: Box<FnMut(int) -> int> = box |&mut: x| x;
+    let mut task: Box<FnMut(int) -> int> = box |x| x;
     task(0);
 
-    call(|:x| x, 22);
+    call(|x| x, 22);
 }
 
 fn call<F:FnOnce(int) -> int>(f: F, x: int) -> int {
diff --git a/src/test/run-pass/unboxed-closures-simple.rs b/src/test/run-pass/unboxed-closures-simple.rs
index c473db4586f..9f29e75be7c 100644
--- a/src/test/run-pass/unboxed-closures-simple.rs
+++ b/src/test/run-pass/unboxed-closures-simple.rs
@@ -13,7 +13,7 @@
 use std::ops::FnMut;
 
 pub fn main() {
-    let mut f = |&mut: x: int, y: int| -> int { x + y };
+    let mut f = |x: int, y: int| -> int { x + y };
     let z = f(1, 2);
     assert_eq!(z, 3);
 }
diff --git a/src/test/run-pass/unboxed-closures-single-word-env.rs b/src/test/run-pass/unboxed-closures-single-word-env.rs
index 61ceb5e140e..9e543f925f8 100644
--- a/src/test/run-pass/unboxed-closures-single-word-env.rs
+++ b/src/test/run-pass/unboxed-closures-single-word-env.rs
@@ -27,8 +27,8 @@ fn c<F:FnOnce(int, int) -> int>(f: F) -> int {
 
 fn main() {
     let z = 10;
-    assert_eq!(a(move |&: x: int, y| x + y + z), 13);
-    assert_eq!(b(move |&mut: x: int, y| x + y + z), 17);
-    assert_eq!(c(move |: x: int, y| x + y + z), 21);
+    assert_eq!(a(move |x: int, y| x + y + z), 13);
+    assert_eq!(b(move |x: int, y| x + y + z), 17);
+    assert_eq!(c(move |x: int, y| x + y + z), 21);
 }
 
diff --git a/src/test/run-pass/unboxed-closures-static-call-fn-once.rs b/src/test/run-pass/unboxed-closures-static-call-fn-once.rs
index e4b35aada9f..7a6b68a5e09 100644
--- a/src/test/run-pass/unboxed-closures-static-call-fn-once.rs
+++ b/src/test/run-pass/unboxed-closures-static-call-fn-once.rs
@@ -11,7 +11,7 @@
 #![feature(unboxed_closures)]
 
 fn main() {
-    let onetime = |: x| x;
+    let onetime = |x| x;
     onetime(0);
 }
 
diff --git a/src/test/run-pass/unboxed-closures-unique-type-id.rs b/src/test/run-pass/unboxed-closures-unique-type-id.rs
index a04301931da..2871b5c6862 100644
--- a/src/test/run-pass/unboxed-closures-unique-type-id.rs
+++ b/src/test/run-pass/unboxed-closures-unique-type-id.rs
@@ -30,6 +30,6 @@ pub fn replace_map<'a, T, F>(src: &mut T, prod: F) where F: FnOnce(T) -> T {
 pub fn main() {
     let mut a = 7u;
     let b = &mut a;
-    replace_map(b, |: x: uint| x * 2);
+    replace_map(b, |x: uint| x * 2);
     assert_eq!(*b, 14u);
 }
diff --git a/src/test/run-pass/unused-move-capture.rs b/src/test/run-pass/unused-move-capture.rs
index a2d1b8780aa..4e8fdda9563 100644
--- a/src/test/run-pass/unused-move-capture.rs
+++ b/src/test/run-pass/unused-move-capture.rs
@@ -13,6 +13,6 @@
 
 pub fn main() {
     let _x = box 1;
-    let lam_move = |&:| {};
+    let lam_move = || {};
     lam_move();
 }
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index 4080796b7a7..c9f070a279c 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -26,7 +26,7 @@ fn what() {
         return while !x.get() { x.set(true); };
     }
     let i = &Cell::new(false);
-    let dont = {|&:|the(i)};
+    let dont = {||the(i)};
     dont();
     assert!((i.get()));
 }
diff --git a/src/test/run-pass/where-clauses-unboxed-closures.rs b/src/test/run-pass/where-clauses-unboxed-closures.rs
index 808e937bc72..7edcdf64292 100644
--- a/src/test/run-pass/where-clauses-unboxed-closures.rs
+++ b/src/test/run-pass/where-clauses-unboxed-closures.rs
@@ -18,9 +18,9 @@ fn warm_up<'a, F>(f: F) where F: Fn(&'a mut Bencher) {
 
 fn main() {
     // ICE trigger
-    warm_up(|&: b: &mut Bencher| () );
+    warm_up(|b: &mut Bencher| () );
 
     // OK
-    warm_up(|&: b| () );
+    warm_up(|b| () );
 }