rustfmt tests

2 files changed, 64 insertions, 62 deletions

diff --git a/src/test/compile-fail/rfc1623.rs b/src/test/compile-fail/rfc1623.rs
index abdcc02de76..3e9afdd5b13 100644
--- a/src/test/compile-fail/rfc1623.rs
+++ b/src/test/compile-fail/rfc1623.rs
@@ -10,12 +10,12 @@
 
 #![allow(dead_code)]
 
-fn non_elidable<'a, 'b>(a: &'a u8, b: &'b u8) -> &'a u8 { a }
+fn non_elidable<'a, 'b>(a: &'a u8, b: &'b u8) -> &'a u8 {
+    a
+}
 
 // the boundaries of elision
-static NON_ELIDABLE_FN : &fn(&u8, &u8) -> &u8 =
-//~^ ERROR: missing lifetime specifier
-        &(non_elidable as fn(&u8, &u8) -> &u8);
+static NON_ELIDABLE_FN: &fn(&u8, &u8) -> &u8 = &(non_elidable as fn(&u8, &u8) -> &u8);
 
 struct SomeStruct<'x, 'y, 'z: 'x> {
     foo: &'x Foo<'z>,
@@ -23,76 +23,78 @@ struct SomeStruct<'x, 'y, 'z: 'x> {
     f: &'y for<'a, 'b: 'a> Fn(&'a Foo<'b>) -> &'a Bar<'b>,
 }
 
-fn id<T>(t: T) -> T { t }
+fn id<T>(t: T) -> T {
+    t
+}
 
-static SOME_STRUCT : &SomeStruct = SomeStruct {
+static SOME_STRUCT: &SomeStruct = SomeStruct {
     foo: &Foo { bools: &[false, true] },
     bar: &Bar { bools: &[true, true] },
     f: &id,
 };
 
 // very simple test for a 'static static with default lifetime
-static STATIC_STR : &'static str = "&'static str";
-const CONST_STR : &'static str = "&'static str";
+static STATIC_STR: &'static str = "&'static str";
+const CONST_STR: &'static str = "&'static str";
 
 // this should be the same as without default:
-static EXPLICIT_STATIC_STR : &'static str = "&'static str";
-const EXPLICIT_CONST_STR : &'static str = "&'static str";
+static EXPLICIT_STATIC_STR: &'static str = "&'static str";
+const EXPLICIT_CONST_STR: &'static str = "&'static str";
 
 // a function that elides to an unbound lifetime for both in- and output
-fn id_u8_slice(arg: &[u8]) -> &[u8] { arg }
+fn id_u8_slice(arg: &[u8]) -> &[u8] {
+    arg
+}
 
 // one with a function, argument elided
-static STATIC_SIMPLE_FN : &'static fn(&[u8]) -> &[u8] =
-        &(id_u8_slice as fn(&[u8]) -> &[u8]);
-const CONST_SIMPLE_FN : &'static fn(&[u8]) -> &[u8] =
-        &(id_u8_slice as fn(&[u8]) -> &[u8]);
+static STATIC_SIMPLE_FN: &'static fn(&[u8]) -> &[u8] = &(id_u8_slice as fn(&[u8]) -> &[u8]);
+const CONST_SIMPLE_FN: &'static fn(&[u8]) -> &[u8] = &(id_u8_slice as fn(&[u8]) -> &[u8]);
 
 // this should be the same as without elision
-static STATIC_NON_ELIDED_fN : &'static for<'a> fn(&'a [u8]) -> &'a [u8] =
-        &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
-const CONST_NON_ELIDED_fN : &'static for<'a> fn(&'a [u8]) -> &'a [u8] =
-        &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
+static STATIC_NON_ELIDED_fN: &'static for<'a> fn(&'a [u8]) -> &'a [u8] =
+    &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
+const CONST_NON_ELIDED_fN: &'static for<'a> fn(&'a [u8]) -> &'a [u8] =
+    &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
 
 // another function that elides, each to a different unbound lifetime
-fn multi_args(a: &u8, b: &u8, c: &u8) { }
+fn multi_args(a: &u8, b: &u8, c: &u8) {}
 
-static STATIC_MULTI_FN : &'static fn(&u8, &u8, &u8) =
-        &(multi_args as fn(&u8, &u8, &u8));
-const CONST_MULTI_FN : &'static fn(&u8, &u8, &u8) =
-        &(multi_args as fn(&u8, &u8, &u8));
+static STATIC_MULTI_FN: &'static fn(&u8, &u8, &u8) = &(multi_args as fn(&u8, &u8, &u8));
+const CONST_MULTI_FN: &'static fn(&u8, &u8, &u8) = &(multi_args as fn(&u8, &u8, &u8));
 
 struct Foo<'a> {
-    bools: &'a [bool]
+    bools: &'a [bool],
 }
 
-static STATIC_FOO : Foo<'static> = Foo { bools: &[true, false] };
-const CONST_FOO : Foo<'static> = Foo { bools: &[true, false] };
+static STATIC_FOO: Foo<'static> = Foo { bools: &[true, false] };
+const CONST_FOO: Foo<'static> = Foo { bools: &[true, false] };
 
 type Bar<'a> = Foo<'a>;
 
-static STATIC_BAR : Bar<'static> = Bar { bools: &[true, false] };
-const CONST_BAR : Bar<'static> = Bar { bools: &[true, false] };
+static STATIC_BAR: Bar<'static> = Bar { bools: &[true, false] };
+const CONST_BAR: Bar<'static> = Bar { bools: &[true, false] };
 
 type Baz<'a> = fn(&'a [u8]) -> Option<u8>;
 
-fn baz(e: &[u8]) -> Option<u8> { e.first().map(|x| *x) }
+fn baz(e: &[u8]) -> Option<u8> {
+    e.first().map(|x| *x)
+}
 
-static STATIC_BAZ : &'static Baz<'static> = &(baz as Baz);
-const CONST_BAZ : &'static Baz<'static> = &(baz as Baz);
+static STATIC_BAZ: &'static Baz<'static> = &(baz as Baz);
+const CONST_BAZ: &'static Baz<'static> = &(baz as Baz);
 
-static BYTES : &'static [u8] = &[1, 2, 3];
+static BYTES: &'static [u8] = &[1, 2, 3];
 
 fn main() {
     let x = &[1u8, 2, 3];
     let y = x;
 
-    //this works, so lifetime < `'static` is valid
+    // this works, so lifetime < `'static` is valid
     assert_eq!(Some(1), STATIC_BAZ(y));
     assert_eq!(Some(1), CONST_BAZ(y));
 
     let y = &[1u8, 2, 3];
-    //^~ ERROR: borrowed values does not live long enough
+    // ^~ ERROR: borrowed values does not live long enough
     STATIC_BAZ(BYTES); // BYTES has static lifetime
     CONST_BAZ(y); // This forces static lifetime, which y has not
 }
diff --git a/src/test/run-pass/rfc1623.rs b/src/test/run-pass/rfc1623.rs
index 0915118ca27..17453933c8a 100644
--- a/src/test/run-pass/rfc1623.rs
+++ b/src/test/run-pass/rfc1623.rs
@@ -11,56 +11,56 @@
 #![allow(dead_code)]
 
 // very simple test for a 'static static with default lifetime
-static STATIC_STR : &str = "&'static str";
-const CONST_STR : &str = "&'static str";
+static STATIC_STR: &str = "&'static str";
+const CONST_STR: &str = "&'static str";
 
 // this should be the same as without default:
-static EXPLICIT_STATIC_STR : &'static str = "&'static str";
-const EXPLICIT_CONST_STR : &'static str = "&'static str";
+static EXPLICIT_STATIC_STR: &'static str = "&'static str";
+const EXPLICIT_CONST_STR: &'static str = "&'static str";
 
 // a function that elides to an unbound lifetime for both in- and output
-fn id_u8_slice(arg: &[u8]) -> &[u8] { arg }
+fn id_u8_slice(arg: &[u8]) -> &[u8] {
+    arg
+}
 
 // one with a function, argument elided
-static STATIC_SIMPLE_FN : &fn(&[u8]) -> &[u8] =
-        &(id_u8_slice as fn(&[u8]) -> &[u8]);
-const CONST_SIMPLE_FN : &fn(&[u8]) -> &[u8] =
-        &(id_u8_slice as fn(&[u8]) -> &[u8]);
+static STATIC_SIMPLE_FN: &fn(&[u8]) -> &[u8] = &(id_u8_slice as fn(&[u8]) -> &[u8]);
+const CONST_SIMPLE_FN: &fn(&[u8]) -> &[u8] = &(id_u8_slice as fn(&[u8]) -> &[u8]);
 
 // this should be the same as without elision
-static STATIC_NON_ELIDED_fN : &for<'a> fn(&'a [u8]) -> &'a [u8] =
-        &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
-const CONST_NON_ELIDED_fN : &for<'a> fn(&'a [u8]) -> &'a [u8] =
-        &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
+static STATIC_NON_ELIDED_fN: &for<'a> fn(&'a [u8]) -> &'a [u8] =
+    &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
+const CONST_NON_ELIDED_fN: &for<'a> fn(&'a [u8]) -> &'a [u8] =
+    &(id_u8_slice as for<'a> fn(&'a [u8]) -> &'a [u8]);
 
 // another function that elides, each to a different unbound lifetime
-fn multi_args(a: &u8, b: &u8, c: &u8) { }
+fn multi_args(a: &u8, b: &u8, c: &u8) {}
 
-static STATIC_MULTI_FN : &fn(&u8, &u8, &u8) =
-        &(multi_args as fn(&u8, &u8, &u8));
-const CONST_MULTI_FN : &fn(&u8, &u8, &u8) =
-        &(multi_args as fn(&u8, &u8, &u8));
+static STATIC_MULTI_FN: &fn(&u8, &u8, &u8) = &(multi_args as fn(&u8, &u8, &u8));
+const CONST_MULTI_FN: &fn(&u8, &u8, &u8) = &(multi_args as fn(&u8, &u8, &u8));
 
 struct Foo<'a> {
-    bools: &'a [bool]
+    bools: &'a [bool],
 }
 
-static STATIC_FOO : Foo = Foo { bools: &[true, false] };
-const CONST_FOO : Foo = Foo { bools: &[true, false] };
+static STATIC_FOO: Foo = Foo { bools: &[true, false] };
+const CONST_FOO: Foo = Foo { bools: &[true, false] };
 
 type Bar<'a> = Foo<'a>;
 
-static STATIC_BAR : Bar = Bar { bools: &[true, false] };
-const CONST_BAR : Bar = Bar { bools: &[true, false] };
+static STATIC_BAR: Bar = Bar { bools: &[true, false] };
+const CONST_BAR: Bar = Bar { bools: &[true, false] };
 
 type Baz<'a> = fn(&'a [u8]) -> Option<u8>;
 
-fn baz(e: &[u8]) -> Option<u8> { e.first().map(|x| *x) }
+fn baz(e: &[u8]) -> Option<u8> {
+    e.first().map(|x| *x)
+}
 
-static STATIC_BAZ : &Baz = &(baz as Baz);
-const CONST_BAZ : &Baz = &(baz as Baz);
+static STATIC_BAZ: &Baz = &(baz as Baz);
+const CONST_BAZ: &Baz = &(baz as Baz);
 
-static BYTES : &[u8] = &[1, 2, 3];
+static BYTES: &[u8] = &[1, 2, 3];
 
 fn main() {
     // make sure that the lifetime is actually elided (and not defaulted)