run rustfmt on test/run-fail folder

src/test/run-fail/args-panic.rs

@@ -14,6 +14,10 @@
 #![allow(unknown_features)]
 #![feature(box_syntax)]
 
-fn f(_a: isize, _b: isize, _c: Box<isize>) { panic!("moop"); }
+fn f(_a: isize, _b: isize, _c: Box<isize>) {
+    panic!("moop");
+}
 
-fn main() { f(1, panic!("meep"), box 42); }
+fn main() {
+    f(1, panic!("meep"), box 42);
+}

src/test/run-fail/assert-eq-macro-panic.rs

@@ -11,5 +11,5 @@
 // error-pattern:assertion failed: `(left == right)` (left: `14`, right: `15`)
 
 fn main() {
-    assert_eq!(14,15);
+    assert_eq!(14, 15);
 }

src/test/run-fail/binop-fail-3.rs

@@ -9,7 +9,9 @@
 // except according to those terms.
 
 // error-pattern:quux
-fn foo() -> ! { panic!("quux"); }
+fn foo() -> ! {
+    panic!("quux");
+}
 fn main() {
     foo() == foo(); // these types wind up being defaulted to ()
 }

src/test/run-fail/binop-panic.rs

@@ -9,5 +9,10 @@
 // except according to those terms.
 
 // error-pattern:quux
-fn my_err(s: String) -> ! { println!("{}", s); panic!("quux"); }
+fn my_err(s: String) -> ! {
-fn main() { 3_usize == my_err("bye".to_string()); }
+    println!("{}", s);
+    panic!("quux");
+}
+fn main() {
+    3_usize == my_err("bye".to_string());
+}

src/test/run-fail/bug-2470-bounds-check-overflow.rs

@@ -20,7 +20,7 @@ fn main() {
     // address of the 0th cell in the array (even though the index is
     // huge).
 
-    let x = vec!(1_usize,2_usize,3_usize);
+    let x = vec![1_usize, 2_usize, 3_usize];
 
     let base = x.as_ptr() as usize;
     let idx = base / mem::size_of::<usize>();
@@ -28,7 +28,7 @@ fn main() {
     println!("ov1 idx = 0x{:x}", idx);
     println!("ov1 sizeof::<usize>() = 0x{:x}", mem::size_of::<usize>());
     println!("ov1 idx * sizeof::<usize>() = 0x{:x}",
-           idx * mem::size_of::<usize>());
+             idx * mem::size_of::<usize>());
 
     // This should panic.
     println!("ov1 0x{:x}", x[idx]);

src/test/run-fail/bug-811.rs

@@ -12,7 +12,9 @@
 
 use std::marker::PhantomData;
 
-fn test00_start(ch: chan_t<isize>, message: isize) { send(ch, message); }
+fn test00_start(ch: chan_t<isize>, message: isize) {
+    send(ch, message);
+}
 
 type task_id = isize;
 type port_id = isize;
@@ -23,6 +25,10 @@ struct chan_t<T> {
     marker: PhantomData<*mut T>,
 }
 
-fn send<T:Send>(_ch: chan_t<T>, _data: T) { panic!(); }
+fn send<T: Send>(_ch: chan_t<T>, _data: T) {
+    panic!();
+}
 
-fn main() { panic!("quux"); }
+fn main() {
+    panic!("quux");
+}

src/test/run-fail/doublepanic.rs

@@ -10,7 +10,7 @@
 
 #![allow(unreachable_code)]
 
-//error-pattern:One
+// error-pattern:One
 fn main() {
     panic!("One");
     panic!("Two");

src/test/run-fail/explicit-panic-msg.rs

@@ -14,6 +14,8 @@
 // error-pattern:wooooo
 fn main() {
     let mut a = 1;
-    if 1 == 1 { a = 2; }
+    if 1 == 1 {
+        a = 2;
+    }
     panic!(format!("woooo{}", "o"));
 }

src/test/run-fail/explicit-panic.rs

@@ -12,4 +12,6 @@
 
 
 // error-pattern:explicit
-fn main() { panic!(); }
+fn main() {
+    panic!();
+}

src/test/run-fail/expr-fn-panic.rs

@@ -10,6 +10,10 @@
 
 // error-pattern:explicit panic
 
-fn f() -> ! { panic!() }
+fn f() -> ! {
+    panic!()
+}
 
-fn main() { f(); }
+fn main() {
+    f();
+}

src/test/run-fail/expr-if-panic-fn.rs

@@ -10,8 +10,19 @@
 
 // error-pattern:explicit panic
 
-fn f() -> ! { panic!() }
+fn f() -> ! {
+    panic!()
+}
 
-fn g() -> isize { let x = if true { f() } else { 10 }; return x; }
+fn g() -> isize {
+    let x = if true {
+        f()
+    } else {
+        10
+    };
+    return x;
+}
 
-fn main() { g(); }
+fn main() {
+    g();
+}

src/test/run-fail/expr-if-panic.rs

@@ -10,4 +10,12 @@
 
 // error-pattern:explicit panic
 
-fn main() { let _x = if false { 0 } else if true { panic!() } else { 10 }; }
+fn main() {
+    let _x = if false {
+        0
+    } else if true {
+        panic!()
+    } else {
+        10
+    };
+}

src/test/run-fail/expr-match-panic-fn.rs

@@ -10,8 +10,18 @@
 
 // error-pattern:explicit panic
 
-fn f() -> ! { panic!() }
+fn f() -> ! {
+    panic!()
+}
 
-fn g() -> isize { let x = match true { true => { f() } false => { 10 } }; return x; }
+fn g() -> isize {
+    let x = match true {
+        true => f(),
+        false => 10,
+    };
+    return x;
+}
 
-fn main() { g(); }
+fn main() {
+    g();
+}

src/test/run-fail/expr-match-panic.rs

@@ -10,4 +10,9 @@
 
 // error-pattern:explicit panic
 
-fn main() { let _x = match true { false => { 0 } true => { panic!() } }; }
+fn main() {
+    let _x = match true {
+        false => 0,
+        true => panic!(),
+    };
+}

src/test/run-fail/for-each-loop-panic.rs

@@ -10,4 +10,8 @@
 
 // error-pattern:moop
 
-fn main() { for _ in 0_usize..10_usize { panic!("moop"); } }
+fn main() {
+    for _ in 0_usize..10_usize {
+        panic!("moop");
+    }
+}

src/test/run-fail/if-check-panic.rs

@@ -12,7 +12,11 @@
 fn even(x: usize) -> bool {
     if x < 2 {
         return false;
-    } else if x == 2 { return true; } else { return even(x - 2); }
+    } else if x == 2 {
+        return true;
+    } else {
+        return even(x - 2);
+    }
 }
 
 fn foo(x: usize) {
@@ -23,4 +27,6 @@ fn foo(x: usize) {
     }
 }
 
-fn main() { foo(3); }
+fn main() {
+    foo(3);
+}

src/test/run-fail/if-cond-bot.rs

@@ -9,5 +9,11 @@
 // except according to those terms.
 
 // error-pattern:quux
-fn my_err(s: String) -> ! { println!("{}", s); panic!("quux"); }
+fn my_err(s: String) -> ! {
-fn main() { if my_err("bye".to_string()) { } }
+    println!("{}", s);
+    panic!("quux");
+}
+fn main() {
+    if my_err("bye".to_string()) {
+    }
+}

src/test/run-fail/issue-12920.rs

@@ -11,5 +11,6 @@
 // error-pattern:explicit panic
 
 pub fn main() {
-    panic!(); println!("{}", 1);
+    panic!();
+    println!("{}", 1);
 }

src/test/run-fail/issue-18576.rs

@@ -20,4 +20,4 @@ fn main() {
     let pointer = other;
     pointer();
 }
-extern fn other() {}
+extern "C" fn other() {}

src/test/run-fail/issue-20971.rs

@@ -19,16 +19,13 @@ pub trait Parser {
 
 impl Parser for () {
     type Input = ();
-    fn parse(&mut self, input: ()) {
+    fn parse(&mut self, input: ()) {}
-
-    }
 }
 
-pub fn many() -> Box<Parser<Input=<() as Parser>::Input> + 'static> {
+pub fn many() -> Box<Parser<Input = <() as Parser>::Input> + 'static> {
     panic!("Hello, world!")
 }
 
 fn main() {
-    many()
+    many().parse(());
-        .parse(());
 }

src/test/run-fail/issue-2444.rs

@@ -12,10 +12,14 @@
 
 use std::sync::Arc;
 
-enum e<T> { ee(Arc<T>) }
+enum e<T> {
+    ee(Arc<T>),
+}
 
-fn foo() -> e<isize> {panic!();}
+fn foo() -> e<isize> {
+    panic!();
+}
 
 fn main() {
-   let _f = foo();
+    let _f = foo();
 }

src/test/run-fail/issue-28934.rs

@@ -17,9 +17,14 @@ struct Parser<'i: 't, 't>(&'i u8, &'t u8);
 
 impl<'i, 't> Parser<'i, 't> {
     fn parse_nested_block<F, T>(&mut self, parse: F) -> Result<T, ()>
-        where for<'tt> F: FnOnce(&mut Parser<'i, 'tt>) -> T { panic!() }
+        where for<'tt> F: FnOnce(&mut Parser<'i, 'tt>) -> T
+    {
+        panic!()
+    }
 
-    fn expect_exhausted(&mut self) -> Result<(), ()> { Ok(()) }
+    fn expect_exhausted(&mut self) -> Result<(), ()> {
+        Ok(())
+    }
 }
 
 fn main() {

src/test/run-fail/issue-3029.rs

@@ -16,7 +16,7 @@
 // error-pattern:so long
 fn main() {
     let mut x = Vec::new();
-    let y = vec!(3);
+    let y = vec![3];
     panic!("so long");
     x.extend(y.into_iter());
 }

src/test/run-fail/issue-6458-1.rs

@@ -11,4 +11,6 @@
 // error-pattern:explicit panic
 
 fn foo<T>(t: T) {}
-fn main() { foo(panic!()) }
+fn main() {
+    foo(panic!())
+}

src/test/run-fail/issue-948.rs

@@ -12,9 +12,12 @@
 
 #![allow(unused_variables)]
 
-struct Point { x: isize, y: isize }
+struct Point {
+    x: isize,
+    y: isize,
+}
 
 fn main() {
-    let origin = Point {x: 0, y: 0};
+    let origin = Point { x: 0, y: 0 };
-    let f: Point = Point {x: (panic!("beep boop")),.. origin};
+    let f: Point = Point { x: (panic!("beep boop")), ..origin };
 }

src/test/run-fail/match-bot-panic.rs

@@ -13,10 +13,12 @@
 #![allow(unreachable_code)]
 #![allow(unused_variables)]
 
-fn foo(s: String) { }
+fn foo(s: String) {}
 
 fn main() {
-    let i =
+    let i = match Some::<isize>(3) {
-        match Some::<isize>(3) { None::<isize> => { panic!() } Some::<isize>(_) => { panic!() } };
+        None::<isize> => panic!(),
+        Some::<isize>(_) => panic!(),
+    };
     foo(i);
 }

src/test/run-fail/match-disc-bot.rs

@@ -9,6 +9,15 @@
 // except according to those terms.
 
 // error-pattern:quux
-fn f() -> ! { panic!("quux") }
+fn f() -> ! {
-fn g() -> isize { match f() { true => { 1 } false => { 0 } } }
+    panic!("quux")
-fn main() { g(); }
+}
+fn g() -> isize {
+    match f() {
+        true => 1,
+        false => 0,
+    }
+}
+fn main() {
+    g();
+}

src/test/run-fail/match-wildcards.rs

@@ -11,10 +11,18 @@
 // error-pattern:squirrelcupcake
 fn cmp() -> isize {
     match (Some('a'), None::<char>) {
-        (Some(_), _) => { panic!("squirrelcupcake"); }
+        (Some(_), _) => {
-        (_, Some(_)) => { panic!(); }
+            panic!("squirrelcupcake");
-        _                    => { panic!("wat"); }
+        }
+        (_, Some(_)) => {
+            panic!();
+        }
+        _ => {
+            panic!("wat");
+        }
     }
 }
 
-fn main() { println!("{}", cmp()); }
+fn main() {
+    println!("{}", cmp());
+}

src/test/run-fail/meta-revision-bad.rs

@@ -16,7 +16,15 @@
 //[foo] error-pattern:bar
 //[bar] error-pattern:foo
 
-#[cfg(foo)] fn die() {panic!("foo");}
+#[cfg(foo)]
-#[cfg(bar)] fn die() {panic!("bar");}
+fn die() {
+    panic!("foo");
+}
+#[cfg(bar)]
+fn die() {
+    panic!("bar");
+}
 
-fn main() { die(); }
+fn main() {
+    die();
+}

src/test/run-fail/meta-revision-ok.rs

@@ -15,7 +15,15 @@
 //[foo] error-pattern:foo
 //[bar] error-pattern:bar
 
-#[cfg(foo)] fn die() {panic!("foo");}
+#[cfg(foo)]
-#[cfg(bar)] fn die() {panic!("bar");}
+fn die() {
+    panic!("foo");
+}
+#[cfg(bar)]
+fn die() {
+    panic!("bar");
+}
 
-fn main() { die(); }
+fn main() {
+    die();
+}

src/test/run-fail/mir_dynamic_drops_1.rs

@@ -27,7 +27,7 @@ impl<'a> Drop for Droppable<'a> {
 }
 
 #[rustc_mir]
-fn mir(){
+fn mir() {
     let (mut xv, mut yv) = (false, false);
     let x = Droppable(&mut xv, 1);
     let y = Droppable(&mut yv, 2);

src/test/run-fail/mir_dynamic_drops_2.rs

@@ -26,7 +26,7 @@ impl<'a> Drop for Droppable<'a> {
 }
 
 #[rustc_mir]
-fn mir<'a>(d: Droppable<'a>){
+fn mir<'a>(d: Droppable<'a>) {
     loop {
         let x = d;
         break;

src/test/run-fail/mir_dynamic_drops_3.rs

@@ -33,7 +33,7 @@ fn may_panic<'a>() -> Droppable<'a> {
 }
 
 #[rustc_mir]
-fn mir<'a>(d: Droppable<'a>){
+fn mir<'a>(d: Droppable<'a>) {
     let (mut a, mut b) = (false, false);
     let y = Droppable(&mut a, 2);
     let x = [Droppable(&mut b, 1), y, d, may_panic()];

src/test/run-fail/panic-arg.rs

@@ -9,6 +9,10 @@
 // except according to those terms.
 
 // error-pattern:woe
-fn f(a: isize) { println!("{}", a); }
+fn f(a: isize) {
+    println!("{}", a);
+}
 
-fn main() { f(panic!("woe")); }
+fn main() {
+    f(panic!("woe"));
+}

src/test/run-fail/panic-macro-any.rs

@@ -14,5 +14,5 @@
 #![feature(box_syntax)]
 
 fn main() {
-    panic!(box 413 as Box<::std::any::Any+Send>);
+    panic!(box 413 as Box<::std::any::Any + Send>);
 }

src/test/run-fail/panic-main.rs

@@ -9,4 +9,6 @@
 // except according to those terms.
 
 // error-pattern:moop
-fn main() { panic!("moop"); }
+fn main() {
+    panic!("moop");
+}

src/test/run-fail/panic-parens.rs

@@ -13,11 +13,15 @@
 // error-pattern:oops
 
 fn bigpanic() {
-    while (panic!("oops")) { if (panic!()) {
+    while (panic!("oops")) {
-        match (panic!()) { () => {
+        if (panic!()) {
+            match (panic!()) {
+                () => {}
+            }
         }
-                     }
+    }
-    }};
 }
 
-fn main() { bigpanic(); }
+fn main() {
+    bigpanic();
+}

src/test/run-fail/panic-task-name-none.rs

@@ -13,8 +13,9 @@
 use std::thread;
 
 fn main() {
-    let r: Result<(),_> = thread::spawn(move|| {
+    let r: Result<(), _> = thread::spawn(move || {
-        panic!("test");
+                               panic!("test");
-    }).join();
+                           })
+                               .join();
     assert!(r.is_ok());
 }

src/test/run-fail/panic-task-name-owned.rs

@@ -13,9 +13,14 @@
 use std::thread::Builder;
 
 fn main() {
-    let r: () = Builder::new().name("owned name".to_string()).spawn(move|| {
+    let r: () = Builder::new()
-        panic!("test");
+                    .name("owned name".to_string())
-        ()
+                    .spawn(move || {
-    }).unwrap().join().unwrap();
+                        panic!("test");
+                        ()
+                    })
+                    .unwrap()
+                    .join()
+                    .unwrap();
     panic!();
 }

src/test/run-fail/panic.rs

@@ -9,4 +9,6 @@
 // except according to those terms.
 
 // error-pattern:1 == 2
-fn main() { assert!(1 == 2); }
+fn main() {
+    assert!(1 == 2);
+}

src/test/run-fail/result-get-panic.rs

@@ -13,5 +13,5 @@
 use std::result::Result::Err;
 
 fn main() {
-    println!("{}", Err::<isize,String>("kitty".to_string()).unwrap());
+    println!("{}", Err::<isize, String>("kitty".to_string()).unwrap());
 }

src/test/run-fail/rhs-type.rs

@@ -15,9 +15,11 @@
 #![allow(unreachable_code)]
 #![allow(unused_variables)]
 
-struct T { t: String }
+struct T {
+    t: String,
+}
 
 fn main() {
     let pth = panic!("bye");
-    let _rs: T = T {t: pth};
+    let _rs: T = T { t: pth };
 }

src/test/run-fail/run-unexported-tests.rs

@@ -14,8 +14,10 @@
 // ignore-pretty: does not work well with `--test`
 
 mod m {
-    pub fn exported() { }
+    pub fn exported() {}
 
     #[test]
-    fn unexported() { panic!("runned an unexported test"); }
+    fn unexported() {
+        panic!("runned an unexported test");
+    }
 }

src/test/run-fail/unimplemented-macro-panic.rs

@@ -9,4 +9,6 @@
 // except according to those terms.
 
 // error-pattern:not yet implemented
-fn main() { unimplemented!() }
+fn main() {
+    unimplemented!()
+}

src/test/run-fail/unique-panic.rs

@@ -10,4 +10,6 @@
 
 // error-pattern: panic
 
-fn main() { Box::new(panic!()); }
+fn main() {
+    Box::new(panic!());
+}

src/test/run-fail/unreachable-macro-panic.rs

@@ -9,4 +9,6 @@
 // except according to those terms.
 
 // error-pattern:internal error: entered unreachable code
-fn main() { unreachable!() }
+fn main() {
+    unreachable!()
+}

src/test/run-fail/unreachable-static-msg.rs

@@ -9,4 +9,6 @@
 // except according to those terms.
 
 // error-pattern:internal error: entered unreachable code: uhoh
-fn main() { unreachable!("uhoh") }
+fn main() {
+    unreachable!("uhoh")
+}

src/test/run-fail/unreachable.rs

@@ -9,4 +9,6 @@
 // except according to those terms.
 
 // error-pattern:internal error: entered unreachable code
-fn main() { unreachable!() }
+fn main() {
+    unreachable!()
+}

src/test/run-fail/unwind-interleaved.rs

@@ -10,13 +10,15 @@
 
 // error-pattern:fail
 
-fn a() { }
+fn a() {}
 
-fn b() { panic!(); }
+fn b() {
+    panic!();
+}
 
 fn main() {
-    let _x = vec!(0);
+    let _x = vec![0];
     a();
-    let _y = vec!(0);
+    let _y = vec![0];
     b();
 }

src/test/run-fail/unwind-rec.rs

@@ -15,10 +15,10 @@ fn build() -> Vec<isize> {
     panic!();
 }
 
-struct Blk { node: Vec<isize> }
+struct Blk {
+    node: Vec<isize>,
+}
 
 fn main() {
-    let _blk = Blk {
+    let _blk = Blk { node: build() };
-        node: build()
-    };
 }

src/test/run-fail/unwind-rec2.rs

@@ -12,18 +12,21 @@
 
 
 fn build1() -> Vec<isize> {
-    vec!(0,0,0,0,0,0,0)
+    vec![0, 0, 0, 0, 0, 0, 0]
 }
 
 fn build2() -> Vec<isize> {
     panic!();
 }
 
-struct Blk { node: Vec<isize> , span: Vec<isize> }
+struct Blk {
+    node: Vec<isize>,
+    span: Vec<isize>,
+}
 
 fn main() {
     let _blk = Blk {
         node: build1(),
-        span: build2()
+        span: build2(),
     };
 }

src/test/run-fail/vec-overrun.rs

@@ -12,7 +12,7 @@
 
 
 fn main() {
-    let v: Vec<isize> = vec!(10);
+    let v: Vec<isize> = vec![10];
     let x: usize = 0;
     assert_eq!(v[x], 10);
     // Bounds-check panic.

src/test/run-fail/while-body-panics.rs

@@ -11,4 +11,11 @@
 #![allow(while_true)]
 
 // error-pattern:quux
-fn main() { let _x: isize = { while true { panic!("quux"); } ; 8 } ; }
+fn main() {
+    let _x: isize = {
+        while true {
+            panic!("quux");
+        }
+        8
+    };
+}

src/test/run-fail/while-panic.rs

@@ -12,5 +12,10 @@
 
 // error-pattern:giraffe
 fn main() {
-    panic!({ while true { panic!("giraffe") }; "clandestine" });
+    panic!({
+        while true {
+            panic!("giraffe")
+        }
+        "clandestine"
+    });
 }