Run rustfmt on tests/run-make/.

With the exception of `tests/run-make/translation/test.rs`, which has a
syntax error.

The expected output in `rustdoc-error-lines/rmake.rs`'s required slight
tweaking.

The two `reproducible-build.rs` files need `// ignore-tidy-linelength`
because rustfmt produces lines longer than 100 chars, which tidy doesn't
like, yuk.

rustfmt.toml

@@ -20,7 +20,7 @@ ignore = [
     "/tests/incremental/",
     "/tests/mir-opt/",
     "/tests/pretty/",
-    "/tests/run-make/",
+    "/tests/run-make/translation/test.rs", # Contains syntax errors.
     "/tests/run-make-fulldeps/",
     "/tests/run-pass-valgrind/",
     "/tests/rustdoc/",

tests/run-make/a-b-a-linker-guard/a.rs

@@ -2,7 +2,7 @@
 #![crate_type = "dylib"]
 
 #[cfg(x)]
-pub fn foo(x: u32) { }
+pub fn foo(x: u32) {}
 
 #[cfg(y)]
-pub fn foo(x: i32) { }
+pub fn foo(x: i32) {}

tests/run-make/allow-non-lint-warnings-cmdline/foo.rs

@@ -2,4 +2,4 @@
 #[derive(Copy, Clone)]
 pub struct Foo;
 
-pub fn main() { }
+pub fn main() {}

tests/run-make/allow-warnings-cmdline-stability/foo.rs

@@ -2,4 +2,6 @@
 
 extern crate bar;
 
-pub fn main() { bar::baz() }
+pub fn main() {
+    bar::baz()
+}

tests/run-make/atomic-lock-free/atomic_lock_free.rs

@@ -1,5 +1,5 @@
 #![feature(no_core, intrinsics, lang_items)]
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 #![no_core]
 
 extern "rust-intrinsic" {

tests/run-make/bare-outfile/foo.rs

@@ -1,2 +1 @@
-fn main() {
+fn main() {}
-}

tests/run-make/box-struct-no-segfault/foo.rs

@@ -1,4 +1,4 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 pub struct Foo(());
 
 impl Foo {

tests/run-make/box-struct-no-segfault/main.rs

@@ -1,4 +1,4 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 extern crate foo;
 use foo::Foo;
 

tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs

@@ -1,16 +1,16 @@
 #![crate_type = "staticlib"]
 #![feature(c_variadic)]
 
-use std::ffi::{c_char, c_double, c_int, c_long, c_longlong};
 use std::ffi::VaList;
-use std::ffi::{CString, CStr};
+use std::ffi::{c_char, c_double, c_int, c_long, c_longlong};
+use std::ffi::{CStr, CString};
 
 macro_rules! continue_if {
     ($cond:expr) => {
         if !($cond) {
             return 0xff;
         }
-    }
+    };
 }
 
 unsafe fn compare_c_str(ptr: *const c_char, val: &str) -> bool {
@@ -59,13 +59,11 @@ pub unsafe extern "C" fn check_list_copy_0(mut ap: VaList) -> usize {
     continue_if!(ap.arg::<c_int>() == 16);
     continue_if!(ap.arg::<c_char>() == 'A' as c_char);
     continue_if!(compare_c_str(ap.arg::<*const c_char>(), "Skip Me!"));
-    ap.with_copy(|mut ap| {
+    ap.with_copy(
-        if compare_c_str(ap.arg::<*const c_char>(), "Correct") {
+        |mut ap| {
-            0
+            if compare_c_str(ap.arg::<*const c_char>(), "Correct") { 0 } else { 0xff }
-        } else {
+        },
-            0xff
+    )
-        }
-    })
 }
 
 #[no_mangle]

tests/run-make/compiler-lookup-paths-2/c.rs

@@ -1,3 +1,3 @@
 #![crate_type = "lib"]
-extern crate b;
 extern crate a;
+extern crate b;

tests/run-make/crate-data-smoke/rmake.rs

@@ -3,41 +3,20 @@ use std::process::Output;
 use run_make_support::{bin_name, rust_lib_name, rustc};
 
 fn compare_stdout<S: AsRef<str>>(output: Output, expected: S) {
-    assert_eq!(
+    assert_eq!(String::from_utf8(output.stdout).unwrap().trim(), expected.as_ref());
-        String::from_utf8(output.stdout).unwrap().trim(),
-        expected.as_ref()
-    );
 }
 
 fn main() {
     compare_stdout(rustc().print("crate-name").input("crate.rs").run(), "foo");
+    compare_stdout(rustc().print("file-names").input("crate.rs").run(), bin_name("foo"));
     compare_stdout(
-        rustc().print("file-names").input("crate.rs").run(),
+        rustc().print("file-names").crate_type("lib").arg("--test").input("crate.rs").run(),
         bin_name("foo"),
     );
     compare_stdout(
-        rustc()
+        rustc().print("file-names").arg("--test").input("lib.rs").run(),
-            .print("file-names")
-            .crate_type("lib")
-            .arg("--test")
-            .input("crate.rs")
-            .run(),
-        bin_name("foo"),
-    );
-    compare_stdout(
-        rustc()
-            .print("file-names")
-            .arg("--test")
-            .input("lib.rs")
-            .run(),
         bin_name("mylib"),
     );
-    compare_stdout(
+    compare_stdout(rustc().print("file-names").input("lib.rs").run(), rust_lib_name("mylib"));
-        rustc().print("file-names").input("lib.rs").run(),
+    compare_stdout(rustc().print("file-names").input("rlib.rs").run(), rust_lib_name("mylib"));
-        rust_lib_name("mylib"),
-    );
-    compare_stdout(
-        rustc().print("file-names").input("rlib.rs").run(),
-        rust_lib_name("mylib"),
-    );
 }

tests/run-make/cross-lang-lto-clang/rustlib.rs

@@ -1,4 +1,4 @@
-#![crate_type="staticlib"]
+#![crate_type = "staticlib"]
 
 #[no_mangle]
 pub extern "C" fn rust_always_inlined() -> u32 {

tests/run-make/cross-lang-lto-pgo-smoketest/rustlib.rs

@@ -1,4 +1,4 @@
-#![crate_type="staticlib"]
+#![crate_type = "staticlib"]
 
 #[no_mangle]
 pub extern "C" fn rust_always_inlined() -> u32 {

tests/run-make/cross-lang-lto-upstream-rlibs/staticlib.rs

@@ -1,4 +1,4 @@
-#![crate_type="staticlib"]
+#![crate_type = "staticlib"]
 
 extern crate upstream;
 

tests/run-make/debug-assertions/debug.rs

@@ -15,19 +15,33 @@ fn main() {
 fn debug_assert_eq() {
     let mut hit1 = false;
     let mut hit2 = false;
-    debug_assert_eq!({ hit1 = true; 1 }, { hit2 = true; 2 });
+    debug_assert_eq!(
+        {
+            hit1 = true;
+            1
+        },
+        {
+            hit2 = true;
+            2
+        }
+    );
     assert!(!hit1);
     assert!(!hit2);
 }
 
 fn debug_assert() {
     let mut hit = false;
-    debug_assert!({ hit = true; false });
+    debug_assert!({
+        hit = true;
+        false
+    });
     assert!(!hit);
 }
 
 fn overflow() {
-    fn add(a: u8, b: u8) -> u8 { a + b }
+    fn add(a: u8, b: u8) -> u8 {
+        a + b
+    }
 
     add(200u8, 200u8);
 }

tests/run-make/dep-info-spaces/lib.rs

@@ -1,4 +1,4 @@
-#[path="foo foo.rs"]
+#[path = "foo foo.rs"]
 pub mod foo;
 
 pub mod bar;

tests/run-make/dep-info/lib.rs

@@ -1,4 +1,4 @@
 #![crate_name = "foo"]
 
-pub mod foo;
 pub mod bar;
+pub mod foo;

tests/run-make/deref-impl-rustdoc-ice/baz.rs

@@ -1,8 +1,10 @@
-extern crate foo;
 extern crate bar;
+extern crate foo;
 
 pub struct Bar;
 impl ::std::ops::Deref for Bar {
     type Target = bar::S;
-    fn deref(&self) -> &Self::Target { unimplemented!() }
+    fn deref(&self) -> &Self::Target {
+        unimplemented!()
+    }
 }

tests/run-make/deref-impl-rustdoc-ice/foo.rs

@@ -3,7 +3,9 @@
 extern crate proc_macro;
 
 #[proc_macro_derive(A)]
-pub fn derive(ts: proc_macro::TokenStream) -> proc_macro::TokenStream { ts }
+pub fn derive(ts: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    ts
+}
 
 #[derive(Debug)]
 struct S;

tests/run-make/dylib-chain/m2.rs

@@ -1,4 +1,6 @@
 #![crate_type = "dylib"]
 extern crate m1;
 
-pub fn m2() { m1::m1() }
+pub fn m2() {
+    m1::m1()
+}

tests/run-make/dylib-chain/m3.rs

@@ -1,4 +1,6 @@
 #![crate_type = "dylib"]
 extern crate m2;
 
-pub fn m3() { m2::m2() }
+pub fn m3() {
+    m2::m2()
+}

tests/run-make/dylib-chain/m4.rs

@@ -1,3 +1,5 @@
 extern crate m3;
 
-fn main() { m3::m3() }
+fn main() {
+    m3::m3()
+}

tests/run-make/emit/test-26235.rs

@@ -6,16 +6,22 @@ fn main() {
     type Key = u32;
     const NUM_THREADS: usize = 2;
 
-    #[derive(Clone,Copy)]
+    #[derive(Clone, Copy)]
     struct Stats<S> {
         upsert: S,
         delete: S,
         insert: S,
-        update: S
+        update: S,
     };
 
-    impl<S> Stats<S> where S: Copy {
+    impl<S> Stats<S>
-        fn dot<B, F, T>(self, s: Stats<T>, f: F) -> Stats<B> where F: Fn(S, T) -> B {
+    where
+        S: Copy,
+    {
+        fn dot<B, F, T>(self, s: Stats<T>, f: F) -> Stats<B>
+        where
+            F: Fn(S, T) -> B,
+        {
             let Stats { upsert: u1, delete: d1, insert: i1, update: p1 } = self;
             let Stats { upsert: u2, delete: d2, insert: i2, update: p2 } = s;
             Stats { upsert: f(u1, u2), delete: f(d1, d2), insert: f(i1, i2), update: f(p1, p2) }
@@ -38,9 +44,12 @@ fn main() {
     make_threads();
 
     {
-        let Stats { ref upsert, ref delete, ref insert, ref update } = stats.iter().fold(
+        let Stats { ref upsert, ref delete, ref insert, ref update } = stats
-            Stats::new(0), |res, &s| res.dot(s, |x: Key, y: Key| x.wrapping_add(y)));
+            .iter()
-        println!("upserts: {}, deletes: {}, inserts: {}, updates: {}",
+            .fold(Stats::new(0), |res, &s| res.dot(s, |x: Key, y: Key| x.wrapping_add(y)));
-                 upsert, delete, insert, update);
+        println!(
+            "upserts: {}, deletes: {}, inserts: {}, updates: {}",
+            upsert, delete, insert, update
+        );
     }
 }

tests/run-make/extern-diff-internal-name/test.rs

@@ -1,5 +1,4 @@
 #[macro_use]
 extern crate foo;
 
-fn main() {
+fn main() {}
-}

tests/run-make/extern-flag-disambiguates/a.rs

@@ -3,4 +3,6 @@
 
 static FOO: usize = 3;
 
-pub fn token() -> &'static usize { &FOO }
+pub fn token() -> &'static usize {
+    &FOO
+}

tests/run-make/extern-flag-disambiguates/b.rs

@@ -5,5 +5,9 @@ extern crate a;
 
 static FOO: usize = 3;
 
-pub fn token() -> &'static usize { &FOO }
+pub fn token() -> &'static usize {
-pub fn a_token() -> &'static usize { a::token() }
+    &FOO
+}
+pub fn a_token() -> &'static usize {
+    a::token()
+}

tests/run-make/extern-flag-disambiguates/c.rs

@@ -5,5 +5,9 @@ extern crate a;
 
 static FOO: usize = 3;
 
-pub fn token() -> &'static usize { &FOO }
+pub fn token() -> &'static usize {
-pub fn a_token() -> &'static usize { a::token() }
+    &FOO
+}
+pub fn a_token() -> &'static usize {
+    a::token()
+}

tests/run-make/extern-flag-disambiguates/d.rs

@@ -1,9 +1,13 @@
-#[cfg(before)] extern crate a;
+#[cfg(before)]
+extern crate a;
+#[cfg(after)]
+extern crate a;
 extern crate b;
 extern crate c;
-#[cfg(after)] extern crate a;
 
-fn t(a: &'static usize) -> usize { a as *const _ as usize }
+fn t(a: &'static usize) -> usize {
+    a as *const _ as usize
+}
 
 fn main() {
     assert_eq!(t(a::token()), t(b::a_token()));

tests/run-make/extern-fn-explicit-align/test.rs

@@ -1,6 +1,6 @@
 // Issue #80127: Passing structs via FFI should work with explicit alignment.
 
-use std::ffi::{CStr, c_char};
+use std::ffi::{c_char, CStr};
 use std::ptr::null_mut;
 
 #[repr(C)]
@@ -18,7 +18,7 @@ pub struct TwoU64s {
 
 #[repr(C)]
 pub struct WrappedU64s {
-    pub a: TwoU64s
+    pub a: TwoU64s,
 }
 
 #[repr(C)]

tests/run-make/extern-fn-reachable/dylib.rs

@@ -1,14 +1,19 @@
 #![crate_type = "dylib"]
 #![allow(dead_code)]
 
-#[no_mangle] pub extern "C" fn fun1() {}
+#[no_mangle]
-#[no_mangle] extern "C" fn fun2() {}
+pub extern "C" fn fun1() {}
+#[no_mangle]
+extern "C" fn fun2() {}
 
 mod foo {
-    #[no_mangle] pub extern "C" fn fun3() {}
+    #[no_mangle]
+    pub extern "C" fn fun3() {}
 }
 pub mod bar {
-    #[no_mangle] pub extern "C" fn fun4() {}
+    #[no_mangle]
+    pub extern "C" fn fun4() {}
 }
 
-#[no_mangle] pub fn fun5() {}
+#[no_mangle]
+pub fn fun5() {}

tests/run-make/extern-fn-struct-passing-abi/test.rs

@@ -90,8 +90,12 @@ extern "C" {
     fn byval_rect_with_many_huge(a: Huge, b: Huge, c: Huge, d: Huge, e: Huge, f: Huge, g: Rect);
 
     fn byval_rect_with_many_huge64(
-        a: Huge64, b: Huge64, c: Huge64,
+        a: Huge64,
-        d: Huge64, e: Huge64, f: Huge64,
+        b: Huge64,
+        c: Huge64,
+        d: Huge64,
+        e: Huge64,
+        f: Huge64,
         g: Rect,
     );
 

tests/run-make/extern-multiple-copies/bar.rs

@@ -1,5 +1,5 @@
-extern crate foo2; // foo2 first to exhibit the bug
 extern crate foo1;
+extern crate foo2; // foo2 first to exhibit the bug
 
 fn main() {
     /* ... */

tests/run-make/external-crate-panic-handle-no-lint/app.rs

@@ -1,7 +1,6 @@
 #![crate_type = "bin"]
 #![no_main]
 #![no_std]
-
 #![deny(unused_extern_crates)]
 
 // `panic` provides a `panic_handler` so it shouldn't trip the `unused_extern_crates` lint

tests/run-make/incr-prev-body-beyond-eof/a.rs

@@ -9,8 +9,4 @@ fn main() {
 // Basically, avoid modifying this file, including adding or removing whitespace!
 fn foo() {
     assert_eq!(1, 1);
-
-
-
-
 }

tests/run-make/incr-prev-body-beyond-eof/b.rs

@@ -8,5 +8,5 @@ fn main() {
 // a.rs, the body must end on a line number which does not exist in b.rs.
 // Basically, avoid modifying this file, including adding or removing whitespace!
 fn foo() {
-    assert_eq!(1, 1);////
+    assert_eq!(1, 1); ////
 }

tests/run-make/inline-always-many-cgu/foo.rs

@@ -2,11 +2,9 @@
 
 pub mod a {
     #[inline(always)]
-    pub fn foo() {
+    pub fn foo() {}
-    }
 
-    pub fn bar() {
+    pub fn bar() {}
-    }
 }
 
 #[no_mangle]

tests/run-make/interdependent-c-libraries/main.rs

@@ -1,5 +1,5 @@
-extern crate foo;
 extern crate bar;
+extern crate foo;
 
 fn main() {
     bar::doit();

tests/run-make/intrinsic-unreachable/exit-ret.rs

@@ -1,4 +1,4 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 use std::arch::asm;
 
 #[deny(unreachable_code)]

tests/run-make/intrinsic-unreachable/exit-unreachable.rs

@@ -1,5 +1,5 @@
 #![feature(core_intrinsics)]
-#![crate_type="lib"]
+#![crate_type = "lib"]
 use std::arch::asm;
 
 use std::intrinsics;

tests/run-make/issue-18943/foo.rs

@@ -1,5 +1,5 @@
-trait Foo { }
+trait Foo {}
 
-trait Bar { }
+trait Bar {}
 
-impl<'a> Foo for Bar + 'a { }
+impl<'a> Foo for Bar + 'a {}

tests/run-make/issue-20626/foo.rs

@@ -1,4 +1,6 @@
-fn identity(a: &u32) -> &u32 { a }
+fn identity(a: &u32) -> &u32 {
+    a
+}
 
 fn print_foo(f: &fn(&u32) -> &u32, x: &u32) {
     print!("{}", (*f)(x));

tests/run-make/issue-22131/foo.rs

@@ -2,4 +2,6 @@
 /// assert_eq!(foo::foo(), 1);
 /// ```
 #[cfg(feature = "bar")]
-pub fn foo() -> i32 { 1 }
+pub fn foo() -> i32 {
+    1
+}

tests/run-make/issue-26006/in/libc/lib.rs

@@ -1,3 +1,3 @@
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
-pub fn something(){}
+pub fn something() {}

tests/run-make/issue-26006/in/time/lib.rs

@@ -1,4 +1,4 @@
 #![feature(rustc_private)]
 extern crate libc;
 
-fn main(){}
+fn main() {}

tests/run-make/issue-37839/b.rs

@@ -1,2 +1,3 @@
 #![crate_type = "lib"]
-#[macro_use] extern crate a;
+#[macro_use]
+extern crate a;

tests/run-make/issue-47551/eh_frame-terminator.rs

@@ -7,9 +7,7 @@ struct Foo {
 
 impl Foo {
     const fn new() -> Self {
-        Self {
+        Self { array: [0x1122_3344_5566_7788; 10240] }
-            array: [0x1122_3344_5566_7788; 10240]
-        }
     }
 }
 

tests/run-make/issue-69368/c.rs

@@ -2,8 +2,8 @@
 #![feature(start)]
 #![no_std]
 
-extern crate alloc;
 extern crate a;
+extern crate alloc;
 extern crate b;
 
 use alloc::vec::Vec;

tests/run-make/link-arg/empty.rs

@@ -1 +1 @@
-fn main() { }
+fn main() {}

tests/run-make/long-linker-command-lines-cmd-exe/foo.rs

@@ -13,13 +13,13 @@
 
 use std::env;
 use std::fs::{self, File};
-use std::io::{BufWriter, Write, Read};
+use std::io::{BufWriter, Read, Write};
 use std::path::PathBuf;
 use std::process::Command;
 
 fn main() {
     if !cfg!(windows) {
-        return
+        return;
     }
 
     let tmpdir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
@@ -31,16 +31,16 @@ fn main() {
                 let file = file.to_str().unwrap();
                 fs::copy(&file[1..], &ok).unwrap();
             }
-            None => { File::create(&not_ok).unwrap(); }
+            None => {
+                File::create(&not_ok).unwrap();
             }
-        return
+        }
+        return;
     }
 
     let rustc = env::var_os("RUSTC").unwrap_or("rustc".into());
     let me = env::current_exe().unwrap();
-    let bat = me.parent()
+    let bat = me.parent().unwrap().join("foo.bat");
-        .unwrap()
-        .join("foo.bat");
     let bat_linker = format!("linker={}", bat.display());
     for i in (1..).map(|i| i * 10) {
         println!("attempt: {}", i);
@@ -61,8 +61,10 @@ fn main() {
         drop(fs::remove_file(&not_ok));
         let status = Command::new(&rustc)
             .arg(&file)
-            .arg("-C").arg(&bat_linker)
+            .arg("-C")
-            .arg("--out-dir").arg(&tmpdir)
+            .arg(&bat_linker)
+            .arg("--out-dir")
+            .arg(&tmpdir)
             .env("YOU_ARE_A_LINKER", "1")
             .env("MY_LINKER", &me)
             .status()
@@ -74,7 +76,7 @@ fn main() {
 
         if !ok.exists() {
             assert!(not_ok.exists());
-            continue
+            continue;
         }
 
         let mut contents = Vec::new();
@@ -96,6 +98,6 @@ fn main() {
             assert!(contents.windows(exp.len()).any(|w| w == &exp[..]));
         }
 
-        break
+        break;
     }
 }

tests/run-make/long-linker-command-lines/foo.rs

@@ -34,9 +34,7 @@ fn write_test_case(file: &Path, n: usize) -> HashSet<String> {
 fn read_linker_args(path: &Path) -> String {
     let contents = fs::read(path).unwrap();
     if cfg!(target_env = "msvc") {
-        let mut i = contents.chunks(2).map(|c| {
+        let mut i = contents.chunks(2).map(|c| c[0] as u16 | ((c[1] as u16) << 8));
-            c[0] as u16 | ((c[1] as u16) << 8)
-        });
         assert_eq!(i.next(), Some(0xfeff), "Expected UTF-16 BOM");
         String::from_utf16(&i.collect::<Vec<u16>>()).unwrap()
     } else {
@@ -52,7 +50,7 @@ fn main() {
             let file = file.to_str().expect("non-utf8 file argument");
             fs::copy(&file[1..], &ok).unwrap();
         }
-        return
+        return;
     }
 
     let rustc = env::var_os("RUSTC").unwrap_or("rustc".into());
@@ -65,28 +63,35 @@ fn main() {
         drop(fs::remove_file(&ok));
         let output = Command::new(&rustc)
             .arg(&file)
-            .arg("-C").arg(&me_as_linker)
+            .arg("-C")
-            .arg("--out-dir").arg(&tmpdir)
+            .arg(&me_as_linker)
+            .arg("--out-dir")
+            .arg(&tmpdir)
             .env("YOU_ARE_A_LINKER", "1")
             .output()
             .unwrap();
 
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
-            panic!("status: {}\nstdout:\n{}\nstderr:\n{}",
+            panic!(
+                "status: {}\nstdout:\n{}\nstderr:\n{}",
                 output.status,
                 String::from_utf8_lossy(&output.stdout),
-                   stderr.lines().map(|l| {
+                stderr
+                    .lines()
+                    .map(|l| {
                         if l.len() > 200 {
                             format!("{}...\n", &l[..200])
                         } else {
                             format!("{}\n", l)
                         }
-                   }).collect::<String>());
+                    })
+                    .collect::<String>()
+            );
         }
 
         if !ok.exists() {
-            continue
+            continue;
         }
 
         let linker_args = read_linker_args(&ok);
@@ -101,6 +106,6 @@ fn main() {
             linker_args,
         );
 
-        break
+        break;
     }
 }

tests/run-make/many-crates-but-no-match/crateA1.rs

@@ -1,4 +1,4 @@
-#![crate_name="crateA"]
+#![crate_name = "crateA"]
 
 // Base crate
 pub fn func<T>() {}

tests/run-make/many-crates-but-no-match/crateA2.rs

@@ -1,4 +1,6 @@
-#![crate_name="crateA"]
+#![crate_name = "crateA"]
 
 // Base crate
-pub fn func<T>() { println!("hello"); }
+pub fn func<T>() {
+    println!("hello");
+}

tests/run-make/many-crates-but-no-match/crateA3.rs

@@ -1,4 +1,6 @@
-#![crate_name="crateA"]
+#![crate_name = "crateA"]
 
 // Base crate
-pub fn foo<T>() { println!("world!"); }
+pub fn foo<T>() {
+    println!("world!");
+}

tests/run-make/metadata-flag-frobs-symbols/foo.rs

@@ -3,4 +3,6 @@
 
 static FOO: usize = 3;
 
-pub fn foo() -> &'static usize { &FOO }
+pub fn foo() -> &'static usize {
+    &FOO
+}

tests/run-make/mixing-deps/dylib.rs

@@ -3,4 +3,6 @@ extern crate both;
 
 use std::mem;
 
-pub fn addr() -> usize { unsafe { mem::transmute(&both::foo) } }
+pub fn addr() -> usize {
+    unsafe { mem::transmute(&both::foo) }
+}

tests/run-make/mixing-deps/prog.rs

@@ -1,9 +1,8 @@
-extern crate dylib;
 extern crate both;
+extern crate dylib;
 
 use std::mem;
 
 fn main() {
-    assert_eq!(unsafe { mem::transmute::<&isize, usize>(&both::foo) },
+    assert_eq!(unsafe { mem::transmute::<&isize, usize>(&both::foo) }, dylib::addr());
-               dylib::addr());
 }

tests/run-make/mixing-libs/dylib.rs

@@ -1,4 +1,6 @@
 #![crate_type = "dylib"]
 extern crate rlib;
 
-pub fn dylib() { rlib::rlib() }
+pub fn dylib() {
+    rlib::rlib()
+}

tests/run-make/native-link-modifier-whole-archive/native_lib_in_src.rs

@@ -1,9 +1,11 @@
 use std::io::Write;
 
-#[link(name = "c_static_lib_with_constructor",
+#[link(
+    name = "c_static_lib_with_constructor",
     kind = "static",
-       modifiers = "-bundle,+whole-archive")]
+    modifiers = "-bundle,+whole-archive"
-extern {}
+)]
+extern "C" {}
 
 pub fn hello() {
     print!("native_lib_in_src.");

tests/run-make/non-pie-thread-local/foo.rs

@@ -2,7 +2,9 @@
 
 struct Destroy;
 impl Drop for Destroy {
-    fn drop(&mut self) { println!("drop"); }
+    fn drop(&mut self) {
+        println!("drop");
+    }
 }
 
 thread_local! {

tests/run-make/pass-non-c-like-enum-to-c/nonclike.rs

@@ -4,7 +4,7 @@ pub enum TT {
     BB,
 }
 
-#[repr(C,u8)]
+#[repr(C, u8)]
 pub enum T {
     A(u64),
     B,
@@ -16,6 +16,6 @@ extern "C" {
 }
 
 fn main() {
-    assert_eq!(33, unsafe { tt_add(TT::AA(1,2), TT::AA(10,20)) });
+    assert_eq!(33, unsafe { tt_add(TT::AA(1, 2), TT::AA(10, 20)) });
     assert_eq!(11, unsafe { t_add(T::A(1), T::A(10)) });
 }

tests/run-make/pdb-buildinfo-cl-cmd/main.rs

@@ -1,2 +1 @@
-fn main() {
+fn main() {}
-}

tests/run-make/pgo-branch-weights/interesting.rs

@@ -1,5 +1,5 @@
-#![crate_name="interesting"]
+#![crate_name = "interesting"]
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 extern crate opaque;
 
@@ -22,7 +22,6 @@ pub fn function_called_42_times(c: char) {
         // This branch is taken 12 times
         opaque::f1();
     } else {
-
         if c == 'b' {
             // This branch is taken 28 times
             opaque::f2();

tests/run-make/pgo-branch-weights/opaque.rs

@@ -1,5 +1,5 @@
-#![crate_name="opaque"]
+#![crate_name = "opaque"]
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 pub fn f1() {}
 pub fn f2() {}

tests/run-make/pgo-indirect-call-promotion/interesting.rs

@@ -1,5 +1,5 @@
-#![crate_name="interesting"]
+#![crate_name = "interesting"]
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 extern crate opaque;
 
@@ -15,7 +15,6 @@ pub fn function_called_never() {
 
 #[no_mangle]
 pub fn call_a_bunch_of_functions(fns: &[fn()]) {
-
     // Indirect call promotion transforms the below into something like
     //
     // for f in fns {
@@ -33,13 +32,11 @@ pub fn call_a_bunch_of_functions(fns: &[fn()]) {
     }
 }
 
-
 pub trait Foo {
     fn foo(&self);
 }
 
 impl Foo for u32 {
-
     #[no_mangle]
     fn foo(&self) {
         opaque::opaque_f2();
@@ -48,7 +45,6 @@ impl Foo for u32 {
 
 #[no_mangle]
 pub fn call_a_bunch_of_trait_methods(trait_objects: &[&dyn Foo]) {
-
     // Same as above, just with vtables in between
     for x in trait_objects {
         x.foo();

tests/run-make/pgo-indirect-call-promotion/main.rs

@@ -2,9 +2,8 @@ extern crate interesting;
 
 fn main() {
     // function pointer case
-    let fns: Vec<_> = std::iter::repeat(interesting::function_called_always as fn())
+    let fns: Vec<_> =
-        .take(1000)
+        std::iter::repeat(interesting::function_called_always as fn()).take(1000).collect();
-        .collect();
     interesting::call_a_bunch_of_functions(&fns[..]);
 
     // Trait object case

tests/run-make/pgo-indirect-call-promotion/opaque.rs

@@ -1,5 +1,5 @@
-#![crate_name="opaque"]
+#![crate_name = "opaque"]
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 #[no_mangle]
 pub fn opaque_f1() {}

tests/run-make/pgo-use/main.rs

@@ -11,7 +11,7 @@ pub fn hot_function(c: u8) {
 fn main() {
     let arg = std::env::args().skip(1).next().unwrap();
 
-    for i in 0 .. 1000_000 {
+    for i in 0..1000_000 {
         let some_value = arg.as_bytes()[i % arg.len()];
         if some_value == b'!' {
             // This branch is never taken at runtime

tests/run-make/pointer-auth-link-with-c/test.rs

@@ -4,5 +4,7 @@ extern "C" {
 }
 
 fn main() {
-    unsafe {foo();}
+    unsafe {
+        foo();
+    }
 }

tests/run-make/pretty-print-to-file/input.rs

@@ -1,5 +1,5 @@
-#[crate_type="lib"]
+#[crate_type = "lib"]
 
-pub fn
+pub fn foo() -> i32 {
-foo() -> i32
+    45
-{ 45 }
+}

tests/run-make/print-check-cfg/rmake.rs

@@ -40,19 +40,21 @@ fn main() {
         /*contains*/ &["feature", "feature=\"\"", "feature=\"test\"", "feature=\"lol\""],
     );
     check(
-        /*args*/ &[
+        /*args*/
+        &[
             r#"--check-cfg=cfg(feature, values(any()))"#,
-            r#"--check-cfg=cfg(feature, values("tmp"))"#
+            r#"--check-cfg=cfg(feature, values("tmp"))"#,
         ],
         /*has_any*/ false,
         /*has_any_any*/ false,
         /*contains*/ &["unix", "miri", "feature=any()"],
     );
     check(
-        /*args*/ &[
+        /*args*/
+        &[
             r#"--check-cfg=cfg(has_foo, has_bar)"#,
             r#"--check-cfg=cfg(feature, values("tmp"))"#,
-            r#"--check-cfg=cfg(feature, values("tmp"))"#
+            r#"--check-cfg=cfg(feature, values("tmp"))"#,
         ],
         /*has_any*/ false,
         /*has_any_any*/ false,

tests/run-make/proc-macro-init-order/b.rs

@@ -1,2 +1,3 @@
 #![crate_type = "lib"]
-#[macro_use] extern crate a;
+#[macro_use]
+extern crate a;

tests/run-make/proc-macro-init-order/c.rs

@@ -1,3 +1,3 @@
 #![crate_type = "staticlib"]
-extern crate b;
 extern crate a;
+extern crate b;

tests/run-make/prune-link-args/empty.rs

@@ -1 +1 @@
-fn main() { }
+fn main() {}

tests/run-make/raw-dylib-alt-calling-convention/driver.rs

@@ -2,7 +2,6 @@ extern crate raw_dylib_alt_calling_convention_test;
 
 fn main() {
     raw_dylib_alt_calling_convention_test::library_function(
-        std::env::args().skip(1).next().map_or(
+        std::env::args().skip(1).next().map_or(false, |s| std::str::FromStr::from_str(&s).unwrap()),
-            false,
+    );
-            |s| std::str::FromStr::from_str(&s).unwrap()));
 }

tests/run-make/raw-dylib-c/lib.rs

@@ -1,16 +1,16 @@
 #[link(name = "extern_1.dll", kind = "raw-dylib", modifiers = "+verbatim")]
-extern {
+extern "C" {
     fn extern_fn_1();
 }
 
 #[link(name = "extern_2", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn extern_fn_3();
 }
 
 pub fn library_function() {
     #[link(name = "extern_1", kind = "raw-dylib")]
-    extern {
+    extern "C" {
         fn extern_fn_2();
         fn print_extern_variable();
         static mut extern_variable: i32;

tests/run-make/raw-dylib-cross-compilation/lib.rs

@@ -8,7 +8,7 @@
 trait Sized {}
 
 #[link(name = "extern_1", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn extern_fn();
 }
 

tests/run-make/raw-dylib-custom-dlltool/lib.rs

@@ -1,5 +1,5 @@
 #[link(name = "extern_1", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn extern_fn_1();
 }
 

tests/run-make/raw-dylib-import-name-type/driver.rs

@@ -76,7 +76,7 @@ extern "vectorcall" {
 }
 
 #[link(name = "extern", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn print_extern_variable_undecorated();
     fn print_extern_variable_noprefix();
     fn print_extern_variable_decorated();

tests/run-make/raw-dylib-inline-cross-dylib/driver.rs

@@ -2,7 +2,7 @@ extern crate raw_dylib_test;
 extern crate raw_dylib_test_wrapper;
 
 #[link(name = "extern_2", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn extern_fn_2();
 }
 

tests/run-make/raw-dylib-inline-cross-dylib/lib.rs

@@ -1,5 +1,5 @@
 #[link(name = "extern_1", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn extern_fn_1();
     fn extern_fn_2();
 }

tests/run-make/raw-dylib-link-ordinal/lib.rs

@@ -1,5 +1,5 @@
 #[link(name = "exporter", kind = "raw-dylib")]
-extern {
+extern "C" {
     #[link_ordinal(13)]
     fn imported_function();
     #[link_ordinal(5)]

tests/run-make/reproducible-build-2/linker.rs

@@ -1,7 +1,7 @@
 use std::env;
-use std::path::Path;
 use std::fs::File;
 use std::io::{Read, Write};
+use std::path::Path;
 
 fn main() {
     let mut dst = env::current_exe().unwrap();
@@ -19,7 +19,7 @@ fn main() {
         if !path.is_file() {
             out.push_str(&arg);
             out.push_str("\n");
-            continue
+            continue;
         }
 
         let mut contents = Vec::new();

tests/run-make/reproducible-build-2/reproducible-build-aux.rs

@@ -1,4 +1,4 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 
 pub static STATIC: i32 = 1234;
 
@@ -18,7 +18,7 @@ impl<T1, T2> Drop for Struct<T1, T2> {
 pub enum Enum {
     Variant1,
     Variant2(u32),
-    Variant3 { x: u32 }
+    Variant3 { x: u32 },
 }
 
 pub struct TupleStruct(pub i8, pub i16, pub i32, pub i64);

tests/run-make/reproducible-build-2/reproducible-build.rs

@@ -18,6 +18,8 @@
 // - Trait object shims
 // - Fn Pointer shims
 
+// ignore-tidy-linelength
+
 #![allow(dead_code, warnings)]
 
 extern crate reproducible_build_aux;
@@ -40,7 +42,7 @@ impl<T1, T2> Drop for Struct<T1, T2> {
 pub enum Enum {
     Variant1,
     Variant2(u32),
-    Variant3 { x: u32 }
+    Variant3 { x: u32 },
 }
 
 struct TupleStruct(i8, i16, i32, i64);
@@ -67,19 +69,14 @@ fn main() {
     generic_fn::<char, Struct<u32, u64>>();
     generic_fn::<Struct<u64, u32>, reproducible_build_aux::Struct<u32, u64>>();
 
-    let dropped = Struct {
+    let dropped = Struct { x: "", y: 'a' };
-        x: "",
-        y: 'a',
-    };
 
     let _ = Enum::Variant1;
     let _ = Enum::Variant2(0);
     let _ = Enum::Variant3 { x: 0 };
     let _ = TupleStruct(1, 2, 3, 4);
 
-    let closure  = |x| {
+    let closure = |x| x + 1i32;
-        x + 1i32
-    };
 
     fn inner<F: Fn(i32) -> i32>(f: F) -> i32 {
         f(STATIC)
@@ -94,13 +91,13 @@ fn main() {
         f(0);
     }
 
-    with_fn_once_adapter(|_:i32| { });
+    with_fn_once_adapter(|_: i32| {});
 
     reproducible_build_aux::regular_fn(STATIC);
     reproducible_build_aux::generic_fn::<u32, char>();
     reproducible_build_aux::generic_fn::<char, Struct<u32, u64>>();
-    reproducible_build_aux::generic_fn::<Struct<u64, u32>,
+    reproducible_build_aux::generic_fn::<Struct<u64, u32>, reproducible_build_aux::Struct<u32, u64>>(
-                                         reproducible_build_aux::Struct<u32, u64>>();
+    );
 
     let _ = reproducible_build_aux::Enum::Variant1;
     let _ = reproducible_build_aux::Enum::Variant2(0);

tests/run-make/reproducible-build/linker.rs

@@ -1,7 +1,7 @@
 use std::env;
-use std::path::Path;
 use std::fs::File;
 use std::io::{Read, Write};
+use std::path::Path;
 
 fn main() {
     let mut dst = env::current_exe().unwrap();
@@ -19,7 +19,7 @@ fn main() {
         if !path.is_file() {
             out.push_str(&arg);
             out.push_str("\n");
-            continue
+            continue;
         }
 
         let mut contents = Vec::new();

tests/run-make/reproducible-build/reproducible-build-aux.rs

@@ -1,4 +1,4 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 
 pub static STATIC: i32 = 1234;
 
@@ -18,7 +18,7 @@ impl<T1, T2> Drop for Struct<T1, T2> {
 pub enum Enum {
     Variant1,
     Variant2(u32),
-    Variant3 { x: u32 }
+    Variant3 { x: u32 },
 }
 
 pub struct TupleStruct(pub i8, pub i16, pub i32, pub i64);

tests/run-make/reproducible-build/reproducible-build.rs

@@ -18,6 +18,8 @@
 // - Trait object shims
 // - Fn Pointer shims
 
+// ignore-tidy-linelength
+
 #![allow(dead_code, warnings)]
 
 extern crate reproducible_build_aux;
@@ -40,7 +42,7 @@ impl<T1, T2> Drop for Struct<T1, T2> {
 pub enum Enum {
     Variant1,
     Variant2(u32),
-    Variant3 { x: u32 }
+    Variant3 { x: u32 },
 }
 
 struct TupleStruct(i8, i16, i32, i64);
@@ -67,19 +69,14 @@ fn main() {
     generic_fn::<char, Struct<u32, u64>>();
     generic_fn::<Struct<u64, u32>, reproducible_build_aux::Struct<u32, u64>>();
 
-    let dropped = Struct {
+    let dropped = Struct { x: "", y: 'a' };
-        x: "",
-        y: 'a',
-    };
 
     let _ = Enum::Variant1;
     let _ = Enum::Variant2(0);
     let _ = Enum::Variant3 { x: 0 };
     let _ = TupleStruct(1, 2, 3, 4);
 
-    let closure  = |x| {
+    let closure = |x| x + 1i32;
-        x + 1i32
-    };
 
     fn inner<F: Fn(i32) -> i32>(f: F) -> i32 {
         f(STATIC)
@@ -94,13 +91,13 @@ fn main() {
         f(0);
     }
 
-    with_fn_once_adapter(|_:i32| { });
+    with_fn_once_adapter(|_: i32| {});
 
     reproducible_build_aux::regular_fn(STATIC);
     reproducible_build_aux::generic_fn::<u32, char>();
     reproducible_build_aux::generic_fn::<char, Struct<u32, u64>>();
-    reproducible_build_aux::generic_fn::<Struct<u64, u32>,
+    reproducible_build_aux::generic_fn::<Struct<u64, u32>, reproducible_build_aux::Struct<u32, u64>>(
-                                         reproducible_build_aux::Struct<u32, u64>>();
+    );
 
     let _ = reproducible_build_aux::Enum::Variant1;
     let _ = reproducible_build_aux::Enum::Variant2(0);

tests/run-make/reset-codegen-1/foo.rs

@@ -1 +1 @@
-fn main() { }
+fn main() {}

tests/run-make/resolve-rename/bar.rs

@@ -2,4 +2,6 @@
 
 extern crate foo;
 
-pub fn bar() { foo::foo() }
+pub fn bar() {
+    foo::foo()
+}

tests/run-make/resolve-rename/baz.rs

@@ -2,4 +2,6 @@
 
 extern crate bar;
 
-pub fn baz() { bar::bar() }
+pub fn baz() {
+    bar::bar()
+}

tests/run-make/return-non-c-like-enum-from-c/nonclike.rs

@@ -4,7 +4,7 @@ pub enum TT {
     BB,
 }
 
-#[repr(C,u8)]
+#[repr(C, u8)]
 pub enum T {
     A(u64),
     B,

tests/run-make/return-non-c-like-enum/nonclike.rs

@@ -9,7 +9,7 @@ pub extern "C" fn tt_new(a: u64, b: u64) -> TT {
     TT::AA(a, b)
 }
 
-#[repr(C,u8)]
+#[repr(C, u8)]
 pub enum T {
     A(u64),
     B,

tests/run-make/rlib-chain/m2.rs

@@ -1,4 +1,6 @@
 #![crate_type = "rlib"]
 extern crate m1;
 
-pub fn m2() { m1::m1() }
+pub fn m2() {
+    m1::m1()
+}

tests/run-make/rlib-chain/m3.rs

@@ -1,4 +1,6 @@
 #![crate_type = "rlib"]
 extern crate m2;
 
-pub fn m3() { m2::m2() }
+pub fn m3() {
+    m2::m2()
+}

tests/run-make/rlib-chain/m4.rs

@@ -1,3 +1,5 @@
 extern crate m3;
 
-fn main() { m3::m3() }
+fn main() {
+    m3::m3()
+}

tests/run-make/rustdoc-error-lines/input.rs

@@ -6,9 +6,7 @@
 /// #![feature(bool_to_option)]
 /// let x: char = 1;
 /// ```
-pub fn foo() {
+pub fn foo() {}
-
-}
 
 /// Add some text around the test...
 ///

tests/run-make/rustdoc-error-lines/rmake.rs

@@ -11,10 +11,10 @@ fn main() {
     let should_contain = &[
         "input.rs - foo (line 5)",
         "input.rs:7:15",
-        "input.rs - bar (line 15)",
+        "input.rs - bar (line 13)",
-        "input.rs:17:15",
+        "input.rs:15:15",
-        "input.rs - bar (line 24)",
+        "input.rs - bar (line 22)",
-        "input.rs:26:15",
+        "input.rs:24:15",
     ];
     for text in should_contain {
         assert!(output.contains(text), "output doesn't contains {:?}", text);

tests/run-make/rustdoc-map-file/foo.rs

@@ -1,5 +1,5 @@
-pub use private::Quz;
 pub use hidden::Bar;
+pub use private::Quz;
 
 mod private {
     pub struct Quz;
@@ -12,5 +12,5 @@ pub mod hidden {
 
 #[macro_export]
 macro_rules! foo {
-    () => {}
+    () => {};
 }

tests/run-make/rustdoc-scrape-examples-invalid-expr/src/lib.rs

@@ -1 +1,3 @@
-pub const fn f() -> usize { 5 }
+pub const fn f() -> usize {
+    5
+}

tests/run-make/rustdoc-scrape-examples-macros/examples/ex.rs

@@ -24,4 +24,4 @@ fn d() {
     a_rules_macro!(()); // no
 }
 
-fn main(){}
+fn main() {}