diff --git a/rustfmt.toml b/rustfmt.toml
index 6f79e4b4e52..dfc41819968 100644
--- a/rustfmt.toml
+++ b/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/",
diff --git a/tests/run-make/a-b-a-linker-guard/a.rs b/tests/run-make/a-b-a-linker-guard/a.rs
index aa07b1e7160..22686760f1a 100644
--- a/tests/run-make/a-b-a-linker-guard/a.rs
+++ b/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) {}
diff --git a/tests/run-make/allow-non-lint-warnings-cmdline/foo.rs b/tests/run-make/allow-non-lint-warnings-cmdline/foo.rs
index 46e72da2de9..02e8ccabf79 100644
--- a/tests/run-make/allow-non-lint-warnings-cmdline/foo.rs
+++ b/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() {}
diff --git a/tests/run-make/allow-warnings-cmdline-stability/foo.rs b/tests/run-make/allow-warnings-cmdline-stability/foo.rs
index 869b5435416..0b91b63c118 100644
--- a/tests/run-make/allow-warnings-cmdline-stability/foo.rs
+++ b/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()
+}
diff --git a/tests/run-make/atomic-lock-free/atomic_lock_free.rs b/tests/run-make/atomic-lock-free/atomic_lock_free.rs
index 47d90b1856b..1f1116b9bfd 100644
--- a/tests/run-make/atomic-lock-free/atomic_lock_free.rs
+++ b/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" {
diff --git a/tests/run-make/bare-outfile/foo.rs b/tests/run-make/bare-outfile/foo.rs
index f79c691f085..f328e4d9d04 100644
--- a/tests/run-make/bare-outfile/foo.rs
+++ b/tests/run-make/bare-outfile/foo.rs
@@ -1,2 +1 @@
-fn main() {
-}
+fn main() {}
diff --git a/tests/run-make/box-struct-no-segfault/foo.rs b/tests/run-make/box-struct-no-segfault/foo.rs
index 1dcabe42dc1..0897b74b356 100644
--- a/tests/run-make/box-struct-no-segfault/foo.rs
+++ b/tests/run-make/box-struct-no-segfault/foo.rs
@@ -1,8 +1,8 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 pub struct Foo(());
 
 impl Foo {
-  pub fn new() -> Foo {
-    Foo(())
-  }
+    pub fn new() -> Foo {
+        Foo(())
+    }
 }
diff --git a/tests/run-make/box-struct-no-segfault/main.rs b/tests/run-make/box-struct-no-segfault/main.rs
index de12b1fd9dc..1a456af48e8 100644
--- a/tests/run-make/box-struct-no-segfault/main.rs
+++ b/tests/run-make/box-struct-no-segfault/main.rs
@@ -1,7 +1,7 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 extern crate foo;
 use foo::Foo;
 
 pub fn crash() -> Box<Foo> {
-  Box::new(Foo::new())
+    Box::new(Foo::new())
 }
diff --git a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs b/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
index e518579b906..196c6440747 100644
--- a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
+++ b/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 @@ unsafe fn compare_c_str(ptr: *const c_char, val: &str) -> bool {
     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| {
-        if compare_c_str(ap.arg::<*const c_char>(), "Correct") {
-            0
-        } else {
-            0xff
-        }
-    })
+    ap.with_copy(
+        |mut ap| {
+            if compare_c_str(ap.arg::<*const c_char>(), "Correct") { 0 } else { 0xff }
+        },
+    )
 }
 
 #[no_mangle]
diff --git a/tests/run-make/compiler-lookup-paths-2/c.rs b/tests/run-make/compiler-lookup-paths-2/c.rs
index e37bc2e1dce..1326edb575e 100644
--- a/tests/run-make/compiler-lookup-paths-2/c.rs
+++ b/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;
diff --git a/tests/run-make/crate-data-smoke/rmake.rs b/tests/run-make/crate-data-smoke/rmake.rs
index 80d43903a53..86fe5593e66 100644
--- a/tests/run-make/crate-data-smoke/rmake.rs
+++ b/tests/run-make/crate-data-smoke/rmake.rs
@@ -3,41 +3,20 @@
 use run_make_support::{bin_name, rust_lib_name, rustc};
 
 fn compare_stdout<S: AsRef<str>>(output: Output, expected: S) {
-    assert_eq!(
-        String::from_utf8(output.stdout).unwrap().trim(),
-        expected.as_ref()
-    );
+    assert_eq!(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()
-            .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(),
+        rustc().print("file-names").arg("--test").input("lib.rs").run(),
         bin_name("mylib"),
     );
-    compare_stdout(
-        rustc().print("file-names").input("lib.rs").run(),
-        rust_lib_name("mylib"),
-    );
-    compare_stdout(
-        rustc().print("file-names").input("rlib.rs").run(),
-        rust_lib_name("mylib"),
-    );
+    compare_stdout(rustc().print("file-names").input("lib.rs").run(), rust_lib_name("mylib"));
+    compare_stdout(rustc().print("file-names").input("rlib.rs").run(), rust_lib_name("mylib"));
 }
diff --git a/tests/run-make/cross-lang-lto-clang/rustlib.rs b/tests/run-make/cross-lang-lto-clang/rustlib.rs
index 8a74d74a420..9aff29ef9bb 100644
--- a/tests/run-make/cross-lang-lto-clang/rustlib.rs
+++ b/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 {
diff --git a/tests/run-make/cross-lang-lto-pgo-smoketest/rustlib.rs b/tests/run-make/cross-lang-lto-pgo-smoketest/rustlib.rs
index 8a74d74a420..9aff29ef9bb 100644
--- a/tests/run-make/cross-lang-lto-pgo-smoketest/rustlib.rs
+++ b/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 {
diff --git a/tests/run-make/cross-lang-lto-upstream-rlibs/staticlib.rs b/tests/run-make/cross-lang-lto-upstream-rlibs/staticlib.rs
index 34951dda3b6..76c24df7898 100644
--- a/tests/run-make/cross-lang-lto-upstream-rlibs/staticlib.rs
+++ b/tests/run-make/cross-lang-lto-upstream-rlibs/staticlib.rs
@@ -1,4 +1,4 @@
-#![crate_type="staticlib"]
+#![crate_type = "staticlib"]
 
 extern crate upstream;
 
diff --git a/tests/run-make/debug-assertions/debug.rs b/tests/run-make/debug-assertions/debug.rs
index 76ca60a71c8..9eebf60ded0 100644
--- a/tests/run-make/debug-assertions/debug.rs
+++ b/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);
 }
diff --git a/tests/run-make/dep-info-spaces/lib.rs b/tests/run-make/dep-info-spaces/lib.rs
index 6264e7b67ec..4e061892cf7 100644
--- a/tests/run-make/dep-info-spaces/lib.rs
+++ b/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;
diff --git a/tests/run-make/dep-info/lib.rs b/tests/run-make/dep-info/lib.rs
index eb8631259d4..6e2781cd4b2 100644
--- a/tests/run-make/dep-info/lib.rs
+++ b/tests/run-make/dep-info/lib.rs
@@ -1,4 +1,4 @@
 #![crate_name = "foo"]
 
-pub mod foo;
 pub mod bar;
+pub mod foo;
diff --git a/tests/run-make/deref-impl-rustdoc-ice/baz.rs b/tests/run-make/deref-impl-rustdoc-ice/baz.rs
index cd2425f9b69..f606ef9bd6b 100644
--- a/tests/run-make/deref-impl-rustdoc-ice/baz.rs
+++ b/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!()
+    }
 }
diff --git a/tests/run-make/deref-impl-rustdoc-ice/foo.rs b/tests/run-make/deref-impl-rustdoc-ice/foo.rs
index a106e4fde5c..df00ed4b9e0 100644
--- a/tests/run-make/deref-impl-rustdoc-ice/foo.rs
+++ b/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;
diff --git a/tests/run-make/dylib-chain/m2.rs b/tests/run-make/dylib-chain/m2.rs
index 62176ddc9f3..92950a91915 100644
--- a/tests/run-make/dylib-chain/m2.rs
+++ b/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()
+}
diff --git a/tests/run-make/dylib-chain/m3.rs b/tests/run-make/dylib-chain/m3.rs
index d213aeda9ac..28a8ca9d7dd 100644
--- a/tests/run-make/dylib-chain/m3.rs
+++ b/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()
+}
diff --git a/tests/run-make/dylib-chain/m4.rs b/tests/run-make/dylib-chain/m4.rs
index fa8ec6079de..c732512af9f 100644
--- a/tests/run-make/dylib-chain/m4.rs
+++ b/tests/run-make/dylib-chain/m4.rs
@@ -1,3 +1,5 @@
 extern crate m3;
 
-fn main() { m3::m3() }
+fn main() {
+    m3::m3()
+}
diff --git a/tests/run-make/emit/test-26235.rs b/tests/run-make/emit/test-26235.rs
index 07d975f3317..d91c46d2dec 100644
--- a/tests/run-make/emit/test-26235.rs
+++ b/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 {
-        fn dot<B, F, T>(self, s: Stats<T>, f: F) -> Stats<B> where F: Fn(S, T) -> B {
+    impl<S> Stats<S>
+    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 make_threads() -> Vec<thread::JoinHandle<()>> {
     make_threads();
 
     {
-        let Stats { ref upsert, ref delete, ref insert, ref update } = stats.iter().fold(
-            Stats::new(0), |res, &s| res.dot(s, |x: Key, y: Key| x.wrapping_add(y)));
-        println!("upserts: {}, deletes: {}, inserts: {}, updates: {}",
-                 upsert, delete, insert, update);
+        let Stats { ref upsert, ref delete, ref insert, ref update } = stats
+            .iter()
+            .fold(Stats::new(0), |res, &s| res.dot(s, |x: Key, y: Key| x.wrapping_add(y)));
+        println!(
+            "upserts: {}, deletes: {}, inserts: {}, updates: {}",
+            upsert, delete, insert, update
+        );
     }
 }
diff --git a/tests/run-make/extern-diff-internal-name/test.rs b/tests/run-make/extern-diff-internal-name/test.rs
index 4c53dc28a80..d210f883316 100644
--- a/tests/run-make/extern-diff-internal-name/test.rs
+++ b/tests/run-make/extern-diff-internal-name/test.rs
@@ -1,5 +1,4 @@
 #[macro_use]
 extern crate foo;
 
-fn main() {
-}
+fn main() {}
diff --git a/tests/run-make/extern-flag-disambiguates/a.rs b/tests/run-make/extern-flag-disambiguates/a.rs
index 2b1a3190150..fe4bb5ccac4 100644
--- a/tests/run-make/extern-flag-disambiguates/a.rs
+++ b/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
+}
diff --git a/tests/run-make/extern-flag-disambiguates/b.rs b/tests/run-make/extern-flag-disambiguates/b.rs
index 1d7a7339ce2..fc3303e5ef8 100644
--- a/tests/run-make/extern-flag-disambiguates/b.rs
+++ b/tests/run-make/extern-flag-disambiguates/b.rs
@@ -5,5 +5,9 @@
 
 static FOO: usize = 3;
 
-pub fn token() -> &'static usize { &FOO }
-pub fn a_token() -> &'static usize { a::token() }
+pub fn token() -> &'static usize {
+    &FOO
+}
+pub fn a_token() -> &'static usize {
+    a::token()
+}
diff --git a/tests/run-make/extern-flag-disambiguates/c.rs b/tests/run-make/extern-flag-disambiguates/c.rs
index 3f9d143ed2d..26ac787e74d 100644
--- a/tests/run-make/extern-flag-disambiguates/c.rs
+++ b/tests/run-make/extern-flag-disambiguates/c.rs
@@ -5,5 +5,9 @@
 
 static FOO: usize = 3;
 
-pub fn token() -> &'static usize { &FOO }
-pub fn a_token() -> &'static usize { a::token() }
+pub fn token() -> &'static usize {
+    &FOO
+}
+pub fn a_token() -> &'static usize {
+    a::token()
+}
diff --git a/tests/run-make/extern-flag-disambiguates/d.rs b/tests/run-make/extern-flag-disambiguates/d.rs
index 249c6a107ff..f0ab2b063e1 100644
--- a/tests/run-make/extern-flag-disambiguates/d.rs
+++ b/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()));
diff --git a/tests/run-make/extern-fn-explicit-align/test.rs b/tests/run-make/extern-fn-explicit-align/test.rs
index 846622de3cd..81991b5919c 100644
--- a/tests/run-make/extern-fn-explicit-align/test.rs
+++ b/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)]
diff --git a/tests/run-make/extern-fn-reachable/dylib.rs b/tests/run-make/extern-fn-reachable/dylib.rs
index cd017934870..fe0c7023b27 100644
--- a/tests/run-make/extern-fn-reachable/dylib.rs
+++ b/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] extern "C" fn fun2() {}
+#[no_mangle]
+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() {}
diff --git a/tests/run-make/extern-fn-struct-passing-abi/test.rs b/tests/run-make/extern-fn-struct-passing-abi/test.rs
index 99e079f98a8..f898592fce9 100644
--- a/tests/run-make/extern-fn-struct-passing-abi/test.rs
+++ b/tests/run-make/extern-fn-struct-passing-abi/test.rs
@@ -90,8 +90,12 @@ fn byval_rect_floats(
     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,
-        d: Huge64, e: Huge64, f: Huge64,
+        a: Huge64,
+        b: Huge64,
+        c: Huge64,
+        d: Huge64,
+        e: Huge64,
+        f: Huge64,
         g: Rect,
     );
 
diff --git a/tests/run-make/extern-multiple-copies/bar.rs b/tests/run-make/extern-multiple-copies/bar.rs
index c6b3595f677..aa0bee77cb2 100644
--- a/tests/run-make/extern-multiple-copies/bar.rs
+++ b/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() {
     /* ... */
diff --git a/tests/run-make/external-crate-panic-handle-no-lint/app.rs b/tests/run-make/external-crate-panic-handle-no-lint/app.rs
index 8127b9578bf..e0168579cca 100644
--- a/tests/run-make/external-crate-panic-handle-no-lint/app.rs
+++ b/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
diff --git a/tests/run-make/incr-prev-body-beyond-eof/a.rs b/tests/run-make/incr-prev-body-beyond-eof/a.rs
index ca70fb56334..59ac2544400 100644
--- a/tests/run-make/incr-prev-body-beyond-eof/a.rs
+++ b/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);
-
-
-
-
 }
diff --git a/tests/run-make/incr-prev-body-beyond-eof/b.rs b/tests/run-make/incr-prev-body-beyond-eof/b.rs
index a272e44a632..2f26a1ffe97 100644
--- a/tests/run-make/incr-prev-body-beyond-eof/b.rs
+++ b/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); ////
 }
diff --git a/tests/run-make/inline-always-many-cgu/foo.rs b/tests/run-make/inline-always-many-cgu/foo.rs
index 65fe69c16fe..b7c5371ea49 100644
--- a/tests/run-make/inline-always-many-cgu/foo.rs
+++ b/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]
diff --git a/tests/run-make/interdependent-c-libraries/main.rs b/tests/run-make/interdependent-c-libraries/main.rs
index 2aba427df47..a429030d3a2 100644
--- a/tests/run-make/interdependent-c-libraries/main.rs
+++ b/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();
diff --git a/tests/run-make/intrinsic-unreachable/exit-ret.rs b/tests/run-make/intrinsic-unreachable/exit-ret.rs
index c8ba5b4599f..3653316b5c6 100644
--- a/tests/run-make/intrinsic-unreachable/exit-ret.rs
+++ b/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)]
diff --git a/tests/run-make/intrinsic-unreachable/exit-unreachable.rs b/tests/run-make/intrinsic-unreachable/exit-unreachable.rs
index 75f893eb2df..d0f193d49ee 100644
--- a/tests/run-make/intrinsic-unreachable/exit-unreachable.rs
+++ b/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;
diff --git a/tests/run-make/issue-18943/foo.rs b/tests/run-make/issue-18943/foo.rs
index d18400dd3a5..54daec8dd1e 100644
--- a/tests/run-make/issue-18943/foo.rs
+++ b/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 {}
diff --git a/tests/run-make/issue-20626/foo.rs b/tests/run-make/issue-20626/foo.rs
index a474e234e72..1007686d9fe 100644
--- a/tests/run-make/issue-20626/foo.rs
+++ b/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));
diff --git a/tests/run-make/issue-22131/foo.rs b/tests/run-make/issue-22131/foo.rs
index 33255d76879..7b955a07b97 100644
--- a/tests/run-make/issue-22131/foo.rs
+++ b/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
+}
diff --git a/tests/run-make/issue-26006/in/libc/lib.rs b/tests/run-make/issue-26006/in/libc/lib.rs
index 23f2bf51800..bad155a99bd 100644
--- a/tests/run-make/issue-26006/in/libc/lib.rs
+++ b/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() {}
diff --git a/tests/run-make/issue-26006/in/time/lib.rs b/tests/run-make/issue-26006/in/time/lib.rs
index 87f2f824a36..51ed27cd713 100644
--- a/tests/run-make/issue-26006/in/time/lib.rs
+++ b/tests/run-make/issue-26006/in/time/lib.rs
@@ -1,4 +1,4 @@
 #![feature(rustc_private)]
 extern crate libc;
 
-fn main(){}
+fn main() {}
diff --git a/tests/run-make/issue-37839/b.rs b/tests/run-make/issue-37839/b.rs
index 355d2b16527..067f47c1b7a 100644
--- a/tests/run-make/issue-37839/b.rs
+++ b/tests/run-make/issue-37839/b.rs
@@ -1,2 +1,3 @@
 #![crate_type = "lib"]
-#[macro_use] extern crate a;
+#[macro_use]
+extern crate a;
diff --git a/tests/run-make/issue-47551/eh_frame-terminator.rs b/tests/run-make/issue-47551/eh_frame-terminator.rs
index 35db4bc7d1f..0c90d8c791c 100644
--- a/tests/run-make/issue-47551/eh_frame-terminator.rs
+++ b/tests/run-make/issue-47551/eh_frame-terminator.rs
@@ -7,9 +7,7 @@ struct Foo {
 
 impl Foo {
     const fn new() -> Self {
-        Self {
-            array: [0x1122_3344_5566_7788; 10240]
-        }
+        Self { array: [0x1122_3344_5566_7788; 10240] }
     }
 }
 
diff --git a/tests/run-make/issue-69368/c.rs b/tests/run-make/issue-69368/c.rs
index 729c4249a05..9d72657aa59 100644
--- a/tests/run-make/issue-69368/c.rs
+++ b/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;
diff --git a/tests/run-make/link-arg/empty.rs b/tests/run-make/link-arg/empty.rs
index 45590d86ba6..f328e4d9d04 100644
--- a/tests/run-make/link-arg/empty.rs
+++ b/tests/run-make/link-arg/empty.rs
@@ -1 +1 @@
-fn main() { }
+fn main() {}
diff --git a/tests/run-make/long-linker-command-lines-cmd-exe/foo.rs b/tests/run-make/long-linker-command-lines-cmd-exe/foo.rs
index 74d7b9b07f6..1d5202dcdb4 100644
--- a/tests/run-make/long-linker-command-lines-cmd-exe/foo.rs
+++ b/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()
-        .unwrap()
-        .join("foo.bat");
+    let bat = me.parent().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("--out-dir").arg(&tmpdir)
+            .arg("-C")
+            .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;
     }
 }
diff --git a/tests/run-make/long-linker-command-lines/foo.rs b/tests/run-make/long-linker-command-lines/foo.rs
index db238c0cf1a..9d4a701ad87 100644
--- a/tests/run-make/long-linker-command-lines/foo.rs
+++ b/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| {
-            c[0] as u16 | ((c[1] as u16) << 8)
-        });
+        let mut i = contents.chunks(2).map(|c| 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("--out-dir").arg(&tmpdir)
+            .arg("-C")
+            .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{}",
-                   output.status,
-                   String::from_utf8_lossy(&output.stdout),
-                   stderr.lines().map(|l| {
-                       if l.len() > 200 {
-                           format!("{}...\n", &l[..200])
-                       } else {
-                           format!("{}\n", l)
-                       }
-                   }).collect::<String>());
+            panic!(
+                "status: {}\nstdout:\n{}\nstderr:\n{}",
+                output.status,
+                String::from_utf8_lossy(&output.stdout),
+                stderr
+                    .lines()
+                    .map(|l| {
+                        if l.len() > 200 {
+                            format!("{}...\n", &l[..200])
+                        } else {
+                            format!("{}\n", l)
+                        }
+                    })
+                    .collect::<String>()
+            );
         }
 
         if !ok.exists() {
-            continue
+            continue;
         }
 
         let linker_args = read_linker_args(&ok);
@@ -101,6 +106,6 @@ fn main() {
             linker_args,
         );
 
-        break
+        break;
     }
 }
diff --git a/tests/run-make/many-crates-but-no-match/crateA1.rs b/tests/run-make/many-crates-but-no-match/crateA1.rs
index 3fed5a38e2c..f3025909b7d 100644
--- a/tests/run-make/many-crates-but-no-match/crateA1.rs
+++ b/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>() {}
diff --git a/tests/run-make/many-crates-but-no-match/crateA2.rs b/tests/run-make/many-crates-but-no-match/crateA2.rs
index 8db07a015ff..ff9f9d4d300 100644
--- a/tests/run-make/many-crates-but-no-match/crateA2.rs
+++ b/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");
+}
diff --git a/tests/run-make/many-crates-but-no-match/crateA3.rs b/tests/run-make/many-crates-but-no-match/crateA3.rs
index a1e8e40a38c..dddf7f728ee 100644
--- a/tests/run-make/many-crates-but-no-match/crateA3.rs
+++ b/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!");
+}
diff --git a/tests/run-make/metadata-flag-frobs-symbols/foo.rs b/tests/run-make/metadata-flag-frobs-symbols/foo.rs
index 696aed2fa1d..cdc8433d8a4 100644
--- a/tests/run-make/metadata-flag-frobs-symbols/foo.rs
+++ b/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
+}
diff --git a/tests/run-make/mixing-deps/dylib.rs b/tests/run-make/mixing-deps/dylib.rs
index 88976d5b663..f3dd134249d 100644
--- a/tests/run-make/mixing-deps/dylib.rs
+++ b/tests/run-make/mixing-deps/dylib.rs
@@ -3,4 +3,6 @@
 
 use std::mem;
 
-pub fn addr() -> usize { unsafe { mem::transmute(&both::foo) } }
+pub fn addr() -> usize {
+    unsafe { mem::transmute(&both::foo) }
+}
diff --git a/tests/run-make/mixing-deps/prog.rs b/tests/run-make/mixing-deps/prog.rs
index 188981dc1a3..1e52ee16982 100644
--- a/tests/run-make/mixing-deps/prog.rs
+++ b/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) },
-               dylib::addr());
+    assert_eq!(unsafe { mem::transmute::<&isize, usize>(&both::foo) }, dylib::addr());
 }
diff --git a/tests/run-make/mixing-libs/dylib.rs b/tests/run-make/mixing-libs/dylib.rs
index 6856887501c..cde5cc139ba 100644
--- a/tests/run-make/mixing-libs/dylib.rs
+++ b/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()
+}
diff --git a/tests/run-make/native-link-modifier-whole-archive/native_lib_in_src.rs b/tests/run-make/native-link-modifier-whole-archive/native_lib_in_src.rs
index 971f3be7a61..d5bc0c3eb69 100644
--- a/tests/run-make/native-link-modifier-whole-archive/native_lib_in_src.rs
+++ b/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",
-       kind = "static",
-       modifiers = "-bundle,+whole-archive")]
-extern {}
+#[link(
+    name = "c_static_lib_with_constructor",
+    kind = "static",
+    modifiers = "-bundle,+whole-archive"
+)]
+extern "C" {}
 
 pub fn hello() {
     print!("native_lib_in_src.");
diff --git a/tests/run-make/non-pie-thread-local/foo.rs b/tests/run-make/non-pie-thread-local/foo.rs
index b67f3847cd4..30d2537750d 100644
--- a/tests/run-make/non-pie-thread-local/foo.rs
+++ b/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! {
diff --git a/tests/run-make/pass-non-c-like-enum-to-c/nonclike.rs b/tests/run-make/pass-non-c-like-enum-to-c/nonclike.rs
index 517286a868d..7b5c620b338 100644
--- a/tests/run-make/pass-non-c-like-enum-to-c/nonclike.rs
+++ b/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 @@ pub enum T {
 }
 
 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)) });
 }
diff --git a/tests/run-make/pdb-buildinfo-cl-cmd/main.rs b/tests/run-make/pdb-buildinfo-cl-cmd/main.rs
index f79c691f085..f328e4d9d04 100644
--- a/tests/run-make/pdb-buildinfo-cl-cmd/main.rs
+++ b/tests/run-make/pdb-buildinfo-cl-cmd/main.rs
@@ -1,2 +1 @@
-fn main() {
-}
+fn main() {}
diff --git a/tests/run-make/pgo-branch-weights/interesting.rs b/tests/run-make/pgo-branch-weights/interesting.rs
index a26d6fd69d1..7066496f4be 100644
--- a/tests/run-make/pgo-branch-weights/interesting.rs
+++ b/tests/run-make/pgo-branch-weights/interesting.rs
@@ -1,5 +1,5 @@
-#![crate_name="interesting"]
-#![crate_type="rlib"]
+#![crate_name = "interesting"]
+#![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();
diff --git a/tests/run-make/pgo-branch-weights/opaque.rs b/tests/run-make/pgo-branch-weights/opaque.rs
index 72f93c9feab..39dedf0f7bf 100644
--- a/tests/run-make/pgo-branch-weights/opaque.rs
+++ b/tests/run-make/pgo-branch-weights/opaque.rs
@@ -1,5 +1,5 @@
-#![crate_name="opaque"]
-#![crate_type="rlib"]
+#![crate_name = "opaque"]
+#![crate_type = "rlib"]
 
 pub fn f1() {}
 pub fn f2() {}
diff --git a/tests/run-make/pgo-indirect-call-promotion/interesting.rs b/tests/run-make/pgo-indirect-call-promotion/interesting.rs
index 4fd096d626d..398017f9611 100644
--- a/tests/run-make/pgo-indirect-call-promotion/interesting.rs
+++ b/tests/run-make/pgo-indirect-call-promotion/interesting.rs
@@ -1,5 +1,5 @@
-#![crate_name="interesting"]
-#![crate_type="rlib"]
+#![crate_name = "interesting"]
+#![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 @@ fn foo(&self) {
 
 #[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();
diff --git a/tests/run-make/pgo-indirect-call-promotion/main.rs b/tests/run-make/pgo-indirect-call-promotion/main.rs
index 27181f30710..604f1f74873 100644
--- a/tests/run-make/pgo-indirect-call-promotion/main.rs
+++ b/tests/run-make/pgo-indirect-call-promotion/main.rs
@@ -2,9 +2,8 @@
 
 fn main() {
     // function pointer case
-    let fns: Vec<_> = std::iter::repeat(interesting::function_called_always as fn())
-        .take(1000)
-        .collect();
+    let fns: Vec<_> =
+        std::iter::repeat(interesting::function_called_always as fn()).take(1000).collect();
     interesting::call_a_bunch_of_functions(&fns[..]);
 
     // Trait object case
diff --git a/tests/run-make/pgo-indirect-call-promotion/opaque.rs b/tests/run-make/pgo-indirect-call-promotion/opaque.rs
index 9628d711c50..d7b2e810bed 100644
--- a/tests/run-make/pgo-indirect-call-promotion/opaque.rs
+++ b/tests/run-make/pgo-indirect-call-promotion/opaque.rs
@@ -1,5 +1,5 @@
-#![crate_name="opaque"]
-#![crate_type="rlib"]
+#![crate_name = "opaque"]
+#![crate_type = "rlib"]
 
 #[no_mangle]
 pub fn opaque_f1() {}
diff --git a/tests/run-make/pgo-use/main.rs b/tests/run-make/pgo-use/main.rs
index eb9192c87e6..6150cff4d63 100644
--- a/tests/run-make/pgo-use/main.rs
+++ b/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
diff --git a/tests/run-make/pointer-auth-link-with-c/test.rs b/tests/run-make/pointer-auth-link-with-c/test.rs
index 615ad0aeb3d..1a3be80e898 100644
--- a/tests/run-make/pointer-auth-link-with-c/test.rs
+++ b/tests/run-make/pointer-auth-link-with-c/test.rs
@@ -4,5 +4,7 @@
 }
 
 fn main() {
-    unsafe {foo();}
+    unsafe {
+        foo();
+    }
 }
diff --git a/tests/run-make/pretty-print-to-file/input.rs b/tests/run-make/pretty-print-to-file/input.rs
index aa828155b20..ce23804e430 100644
--- a/tests/run-make/pretty-print-to-file/input.rs
+++ b/tests/run-make/pretty-print-to-file/input.rs
@@ -1,5 +1,5 @@
-#[crate_type="lib"]
+#[crate_type = "lib"]
 
-pub fn
-foo() -> i32
-{ 45 }
+pub fn foo() -> i32 {
+    45
+}
diff --git a/tests/run-make/print-check-cfg/rmake.rs b/tests/run-make/print-check-cfg/rmake.rs
index 554884b7d57..f7f5fcf2340 100644
--- a/tests/run-make/print-check-cfg/rmake.rs
+++ b/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,
diff --git a/tests/run-make/proc-macro-init-order/b.rs b/tests/run-make/proc-macro-init-order/b.rs
index 355d2b16527..067f47c1b7a 100644
--- a/tests/run-make/proc-macro-init-order/b.rs
+++ b/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;
diff --git a/tests/run-make/proc-macro-init-order/c.rs b/tests/run-make/proc-macro-init-order/c.rs
index b9c2155728c..505f8470338 100644
--- a/tests/run-make/proc-macro-init-order/c.rs
+++ b/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;
diff --git a/tests/run-make/prune-link-args/empty.rs b/tests/run-make/prune-link-args/empty.rs
index 45590d86ba6..f328e4d9d04 100644
--- a/tests/run-make/prune-link-args/empty.rs
+++ b/tests/run-make/prune-link-args/empty.rs
@@ -1 +1 @@
-fn main() { }
+fn main() {}
diff --git a/tests/run-make/raw-dylib-alt-calling-convention/driver.rs b/tests/run-make/raw-dylib-alt-calling-convention/driver.rs
index b7f372c6b2b..918e013af6e 100644
--- a/tests/run-make/raw-dylib-alt-calling-convention/driver.rs
+++ b/tests/run-make/raw-dylib-alt-calling-convention/driver.rs
@@ -2,7 +2,6 @@
 
 fn main() {
     raw_dylib_alt_calling_convention_test::library_function(
-        std::env::args().skip(1).next().map_or(
-            false,
-            |s| std::str::FromStr::from_str(&s).unwrap()));
+        std::env::args().skip(1).next().map_or(false, |s| std::str::FromStr::from_str(&s).unwrap()),
+    );
 }
diff --git a/tests/run-make/raw-dylib-c/lib.rs b/tests/run-make/raw-dylib-c/lib.rs
index f17125f308c..ebb08a0ba9e 100644
--- a/tests/run-make/raw-dylib-c/lib.rs
+++ b/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;
diff --git a/tests/run-make/raw-dylib-cross-compilation/lib.rs b/tests/run-make/raw-dylib-cross-compilation/lib.rs
index 3338ac0a0b5..d3b7fd23ca8 100644
--- a/tests/run-make/raw-dylib-cross-compilation/lib.rs
+++ b/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();
 }
 
diff --git a/tests/run-make/raw-dylib-custom-dlltool/lib.rs b/tests/run-make/raw-dylib-custom-dlltool/lib.rs
index 2f3f497a00d..db1d6450503 100644
--- a/tests/run-make/raw-dylib-custom-dlltool/lib.rs
+++ b/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();
 }
 
diff --git a/tests/run-make/raw-dylib-import-name-type/driver.rs b/tests/run-make/raw-dylib-import-name-type/driver.rs
index 6c1c212f187..b235fef9e30 100644
--- a/tests/run-make/raw-dylib-import-name-type/driver.rs
+++ b/tests/run-make/raw-dylib-import-name-type/driver.rs
@@ -76,7 +76,7 @@
 }
 
 #[link(name = "extern", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn print_extern_variable_undecorated();
     fn print_extern_variable_noprefix();
     fn print_extern_variable_decorated();
diff --git a/tests/run-make/raw-dylib-inline-cross-dylib/driver.rs b/tests/run-make/raw-dylib-inline-cross-dylib/driver.rs
index 0c3125be6f5..53f3fcb2f88 100644
--- a/tests/run-make/raw-dylib-inline-cross-dylib/driver.rs
+++ b/tests/run-make/raw-dylib-inline-cross-dylib/driver.rs
@@ -2,7 +2,7 @@
 extern crate raw_dylib_test_wrapper;
 
 #[link(name = "extern_2", kind = "raw-dylib")]
-extern {
+extern "C" {
     fn extern_fn_2();
 }
 
diff --git a/tests/run-make/raw-dylib-inline-cross-dylib/lib.rs b/tests/run-make/raw-dylib-inline-cross-dylib/lib.rs
index 4877cb80aea..07e289a21d9 100644
--- a/tests/run-make/raw-dylib-inline-cross-dylib/lib.rs
+++ b/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();
 }
diff --git a/tests/run-make/raw-dylib-link-ordinal/lib.rs b/tests/run-make/raw-dylib-link-ordinal/lib.rs
index 1bbb45bbc77..69f0a5bca46 100644
--- a/tests/run-make/raw-dylib-link-ordinal/lib.rs
+++ b/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)]
diff --git a/tests/run-make/reproducible-build-2/linker.rs b/tests/run-make/reproducible-build-2/linker.rs
index 998d1f32859..ec238b2fa56 100644
--- a/tests/run-make/reproducible-build-2/linker.rs
+++ b/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();
diff --git a/tests/run-make/reproducible-build-2/reproducible-build-aux.rs b/tests/run-make/reproducible-build-2/reproducible-build-aux.rs
index 8105b3d2bda..9708b2d15b4 100644
--- a/tests/run-make/reproducible-build-2/reproducible-build-aux.rs
+++ b/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 @@ fn drop(&mut self) {}
 pub enum Enum {
     Variant1,
     Variant2(u32),
-    Variant3 { x: u32 }
+    Variant3 { x: u32 },
 }
 
 pub struct TupleStruct(pub i8, pub i16, pub i32, pub i64);
diff --git a/tests/run-make/reproducible-build-2/reproducible-build.rs b/tests/run-make/reproducible-build-2/reproducible-build.rs
index a6c04774c86..849b3d510af 100644
--- a/tests/run-make/reproducible-build-2/reproducible-build.rs
+++ b/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 @@ fn drop(&mut self) {}
 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 {
-        x: "",
-        y: 'a',
-    };
+    let dropped = Struct { x: "", y: 'a' };
 
     let _ = Enum::Variant1;
     let _ = Enum::Variant2(0);
     let _ = Enum::Variant3 { x: 0 };
     let _ = TupleStruct(1, 2, 3, 4);
 
-    let closure  = |x| {
-        x + 1i32
-    };
+    let closure = |x| x + 1i32;
 
     fn inner<F: Fn(i32) -> i32>(f: F) -> i32 {
         f(STATIC)
@@ -94,13 +91,13 @@ fn with_fn_once_adapter<F: FnOnce(i32)>(f: F) {
         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::Struct<u32, u64>>();
+    reproducible_build_aux::generic_fn::<Struct<u64, u32>, reproducible_build_aux::Struct<u32, u64>>(
+    );
 
     let _ = reproducible_build_aux::Enum::Variant1;
     let _ = reproducible_build_aux::Enum::Variant2(0);
diff --git a/tests/run-make/reproducible-build/linker.rs b/tests/run-make/reproducible-build/linker.rs
index 3dda6f190e4..ab3b4049cc3 100644
--- a/tests/run-make/reproducible-build/linker.rs
+++ b/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();
diff --git a/tests/run-make/reproducible-build/reproducible-build-aux.rs b/tests/run-make/reproducible-build/reproducible-build-aux.rs
index 8105b3d2bda..9708b2d15b4 100644
--- a/tests/run-make/reproducible-build/reproducible-build-aux.rs
+++ b/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 @@ fn drop(&mut self) {}
 pub enum Enum {
     Variant1,
     Variant2(u32),
-    Variant3 { x: u32 }
+    Variant3 { x: u32 },
 }
 
 pub struct TupleStruct(pub i8, pub i16, pub i32, pub i64);
diff --git a/tests/run-make/reproducible-build/reproducible-build.rs b/tests/run-make/reproducible-build/reproducible-build.rs
index a6c04774c86..849b3d510af 100644
--- a/tests/run-make/reproducible-build/reproducible-build.rs
+++ b/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 @@ fn drop(&mut self) {}
 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 {
-        x: "",
-        y: 'a',
-    };
+    let dropped = Struct { x: "", y: 'a' };
 
     let _ = Enum::Variant1;
     let _ = Enum::Variant2(0);
     let _ = Enum::Variant3 { x: 0 };
     let _ = TupleStruct(1, 2, 3, 4);
 
-    let closure  = |x| {
-        x + 1i32
-    };
+    let closure = |x| x + 1i32;
 
     fn inner<F: Fn(i32) -> i32>(f: F) -> i32 {
         f(STATIC)
@@ -94,13 +91,13 @@ fn with_fn_once_adapter<F: FnOnce(i32)>(f: F) {
         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::Struct<u32, u64>>();
+    reproducible_build_aux::generic_fn::<Struct<u64, u32>, reproducible_build_aux::Struct<u32, u64>>(
+    );
 
     let _ = reproducible_build_aux::Enum::Variant1;
     let _ = reproducible_build_aux::Enum::Variant2(0);
diff --git a/tests/run-make/reset-codegen-1/foo.rs b/tests/run-make/reset-codegen-1/foo.rs
index 45590d86ba6..f328e4d9d04 100644
--- a/tests/run-make/reset-codegen-1/foo.rs
+++ b/tests/run-make/reset-codegen-1/foo.rs
@@ -1 +1 @@
-fn main() { }
+fn main() {}
diff --git a/tests/run-make/resolve-rename/bar.rs b/tests/run-make/resolve-rename/bar.rs
index 4a09ce355e6..706ff453520 100644
--- a/tests/run-make/resolve-rename/bar.rs
+++ b/tests/run-make/resolve-rename/bar.rs
@@ -2,4 +2,6 @@
 
 extern crate foo;
 
-pub fn bar() { foo::foo() }
+pub fn bar() {
+    foo::foo()
+}
diff --git a/tests/run-make/resolve-rename/baz.rs b/tests/run-make/resolve-rename/baz.rs
index 9176073ef97..74822fb4e1e 100644
--- a/tests/run-make/resolve-rename/baz.rs
+++ b/tests/run-make/resolve-rename/baz.rs
@@ -2,4 +2,6 @@
 
 extern crate bar;
 
-pub fn baz() { bar::bar() }
+pub fn baz() {
+    bar::bar()
+}
diff --git a/tests/run-make/return-non-c-like-enum-from-c/nonclike.rs b/tests/run-make/return-non-c-like-enum-from-c/nonclike.rs
index ea22a2a56e0..1cd6360bdd2 100644
--- a/tests/run-make/return-non-c-like-enum-from-c/nonclike.rs
+++ b/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,
diff --git a/tests/run-make/return-non-c-like-enum/nonclike.rs b/tests/run-make/return-non-c-like-enum/nonclike.rs
index de529cf641a..32884d8d690 100644
--- a/tests/run-make/return-non-c-like-enum/nonclike.rs
+++ 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,
diff --git a/tests/run-make/rlib-chain/m2.rs b/tests/run-make/rlib-chain/m2.rs
index eba12fe1218..9430e1d156c 100644
--- a/tests/run-make/rlib-chain/m2.rs
+++ 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()
+}
diff --git a/tests/run-make/rlib-chain/m3.rs b/tests/run-make/rlib-chain/m3.rs
index ade191db49c..b45712e55e1 100644
--- a/tests/run-make/rlib-chain/m3.rs
+++ b/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()
+}
diff --git a/tests/run-make/rlib-chain/m4.rs b/tests/run-make/rlib-chain/m4.rs
index fa8ec6079de..c732512af9f 100644
--- a/tests/run-make/rlib-chain/m4.rs
+++ b/tests/run-make/rlib-chain/m4.rs
@@ -1,3 +1,5 @@
 extern crate m3;
 
-fn main() { m3::m3() }
+fn main() {
+    m3::m3()
+}
diff --git a/tests/run-make/rustdoc-error-lines/input.rs b/tests/run-make/rustdoc-error-lines/input.rs
index b4db182e85f..1ca2efc0dd5 100644
--- a/tests/run-make/rustdoc-error-lines/input.rs
+++ b/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...
 ///
diff --git a/tests/run-make/rustdoc-error-lines/rmake.rs b/tests/run-make/rustdoc-error-lines/rmake.rs
index 31536c78dd4..db6e28e4feb 100644
--- a/tests/run-make/rustdoc-error-lines/rmake.rs
+++ b/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:17:15",
-        "input.rs - bar (line 24)",
-        "input.rs:26:15",
+        "input.rs - bar (line 13)",
+        "input.rs:15:15",
+        "input.rs - bar (line 22)",
+        "input.rs:24:15",
     ];
     for text in should_contain {
         assert!(output.contains(text), "output doesn't contains {:?}", text);
diff --git a/tests/run-make/rustdoc-map-file/foo.rs b/tests/run-make/rustdoc-map-file/foo.rs
index e12b9d2292c..f98543f9b05 100644
--- a/tests/run-make/rustdoc-map-file/foo.rs
+++ b/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 {
-    () => {}
+    () => {};
 }
diff --git a/tests/run-make/rustdoc-scrape-examples-invalid-expr/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-invalid-expr/src/lib.rs
index c30c99dec60..ba8ee66fc78 100644
--- a/tests/run-make/rustdoc-scrape-examples-invalid-expr/src/lib.rs
+++ b/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
+}
diff --git a/tests/run-make/rustdoc-scrape-examples-macros/examples/ex.rs b/tests/run-make/rustdoc-scrape-examples-macros/examples/ex.rs
index 4d8c8b30e31..70a9a187f07 100644
--- a/tests/run-make/rustdoc-scrape-examples-macros/examples/ex.rs
+++ b/tests/run-make/rustdoc-scrape-examples-macros/examples/ex.rs
@@ -8,20 +8,20 @@
 
 #[an_attr_macro]
 fn a() {
-  f(); // no
+    f(); // no
 }
 
 #[an_attr_macro(with_span)]
 fn b() {
-  f(); // yes
+    f(); // yes
 }
 
 fn c() {
-  a_rules_macro!(f()); // yes
+    a_rules_macro!(f()); // yes
 }
 
 fn d() {
-  a_rules_macro!(()); // no
+    a_rules_macro!(()); // no
 }
 
-fn main(){}
+fn main() {}
diff --git a/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs
index d8658a0f255..26ab1390a49 100644
--- a/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs
+++ b/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs
@@ -8,5 +8,7 @@ pub fn f() {}
 
 #[macro_export]
 macro_rules! a_rules_macro {
-  ($e:expr) => { ($e, foobar::f()); }
+    ($e:expr) => {
+        ($e, foobar::f());
+    };
 }
diff --git a/tests/run-make/rustdoc-scrape-examples-test/examples/ex.rs b/tests/run-make/rustdoc-scrape-examples-test/examples/ex.rs
index d1a9a74e782..c37b8dd4885 100644
--- a/tests/run-make/rustdoc-scrape-examples-test/examples/ex.rs
+++ b/tests/run-make/rustdoc-scrape-examples-test/examples/ex.rs
@@ -2,5 +2,5 @@ fn main() {}
 
 #[test]
 fn a_test() {
-  foobar::ok();
+    foobar::ok();
 }
diff --git a/tests/run-make/rustdoc-scrape-examples-whitespace/examples/ex.rs b/tests/run-make/rustdoc-scrape-examples-whitespace/examples/ex.rs
index 44ff689dfc8..09df782a136 100644
--- a/tests/run-make/rustdoc-scrape-examples-whitespace/examples/ex.rs
+++ b/tests/run-make/rustdoc-scrape-examples-whitespace/examples/ex.rs
@@ -1,8 +1,10 @@
 struct Foo;
 impl Foo {
-  fn bar() { foobar::ok(); }
+    fn bar() {
+        foobar::ok();
+    }
 }
 
 fn main() {
-  Foo::bar();
+    Foo::bar();
 }
diff --git a/tests/run-make/share-generics-dylib/linked_leaf.rs b/tests/run-make/share-generics-dylib/linked_leaf.rs
index e510dad691c..200a732d588 100644
--- a/tests/run-make/share-generics-dylib/linked_leaf.rs
+++ b/tests/run-make/share-generics-dylib/linked_leaf.rs
@@ -1,11 +1,12 @@
+// Blank line after this one because it must come before `instance_user_{a,b}_rlib`.
 extern crate instance_user_dylib;
+
 extern crate instance_user_a_rlib;
 extern crate instance_user_b_rlib;
 
 use std::cell::Cell;
 
 fn main() {
-
     instance_user_a_rlib::foo();
     instance_user_b_rlib::foo();
     instance_user_dylib::foo();
diff --git a/tests/run-make/split-debuginfo/main.rs b/tests/run-make/split-debuginfo/main.rs
index 21fa16e40a4..e815672fa81 100644
--- a/tests/run-make/split-debuginfo/main.rs
+++ b/tests/run-make/split-debuginfo/main.rs
@@ -1,6 +1,6 @@
 extern crate bar;
 
-use bar::{Bar, make_bar};
+use bar::{make_bar, Bar};
 
 fn main() {
     let b = make_bar(3);
diff --git a/tests/run-make/stable-symbol-names/stable-symbol-names1.rs b/tests/run-make/stable-symbol-names/stable-symbol-names1.rs
index b85a428278c..ff20d4306dd 100644
--- a/tests/run-make/stable-symbol-names/stable-symbol-names1.rs
+++ b/tests/run-make/stable-symbol-names/stable-symbol-names1.rs
@@ -1,31 +1,31 @@
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 pub trait Foo {
-  fn generic_method<T>();
+    fn generic_method<T>();
 }
 
 pub struct Bar;
 
 impl Foo for Bar {
-  fn generic_method<T>() {}
+    fn generic_method<T>() {}
 }
 
 pub fn mono_function() {
-  Bar::generic_method::<Bar>();
+    Bar::generic_method::<Bar>();
 }
 
 pub fn mono_function_lifetime<'a>(x: &'a u64) -> u64 {
-  *x
+    *x
 }
 
 pub fn generic_function<T>(t: T) -> T {
-  t
+    t
 }
 
 pub fn user() {
-  generic_function(0u32);
-  generic_function("abc");
-  let x = 2u64;
-  generic_function(&x);
-  let _ = mono_function_lifetime(&x);
+    generic_function(0u32);
+    generic_function("abc");
+    let x = 2u64;
+    generic_function(&x);
+    let _ = mono_function_lifetime(&x);
 }
diff --git a/tests/run-make/stable-symbol-names/stable-symbol-names2.rs b/tests/run-make/stable-symbol-names/stable-symbol-names2.rs
index 33df9d6c689..6a50c2a4f57 100644
--- a/tests/run-make/stable-symbol-names/stable-symbol-names2.rs
+++ b/tests/run-make/stable-symbol-names/stable-symbol-names2.rs
@@ -1,17 +1,17 @@
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 extern crate stable_symbol_names1;
 
 pub fn user() {
-  stable_symbol_names1::generic_function(1u32);
-  stable_symbol_names1::generic_function("def");
-  let x = 2u64;
-  stable_symbol_names1::generic_function(&x);
-  stable_symbol_names1::mono_function();
-  stable_symbol_names1::mono_function_lifetime(&0);
+    stable_symbol_names1::generic_function(1u32);
+    stable_symbol_names1::generic_function("def");
+    let x = 2u64;
+    stable_symbol_names1::generic_function(&x);
+    stable_symbol_names1::mono_function();
+    stable_symbol_names1::mono_function_lifetime(&0);
 }
 
 pub fn trait_impl_test_function() {
-  use stable_symbol_names1::*;
-  Bar::generic_method::<Bar>();
+    use stable_symbol_names1::*;
+    Bar::generic_method::<Bar>();
 }
diff --git a/tests/run-make/static-unwinding/lib.rs b/tests/run-make/static-unwinding/lib.rs
index 3fb1117a110..975de43cfd8 100644
--- a/tests/run-make/static-unwinding/lib.rs
+++ b/tests/run-make/static-unwinding/lib.rs
@@ -5,11 +5,16 @@
 struct A;
 impl Drop for A {
     fn drop(&mut self) {
-        unsafe { statik = 1; }
+        unsafe {
+            statik = 1;
+        }
     }
 }
 
-pub fn callback<F>(f: F) where F: FnOnce() {
+pub fn callback<F>(f: F)
+where
+    F: FnOnce(),
+{
     let _a = A;
     f();
 }
diff --git a/tests/run-make/static-unwinding/main.rs b/tests/run-make/static-unwinding/main.rs
index 0c66ea1aa07..ceb0a24804c 100644
--- a/tests/run-make/static-unwinding/main.rs
+++ b/tests/run-make/static-unwinding/main.rs
@@ -7,15 +7,19 @@
 struct A;
 impl Drop for A {
     fn drop(&mut self) {
-        unsafe { statik = 1; }
+        unsafe {
+            statik = 1;
+        }
     }
 }
 
 fn main() {
-    thread::spawn(move|| {
+    thread::spawn(move || {
         let _a = A;
         lib::callback(|| panic!());
-    }).join().unwrap_err();
+    })
+    .join()
+    .unwrap_err();
 
     unsafe {
         assert_eq!(lib::statik, 1);
diff --git a/tests/run-make/suspicious-library/bar.rs b/tests/run-make/suspicious-library/bar.rs
index 550c94cd0c6..030693a694f 100644
--- a/tests/run-make/suspicious-library/bar.rs
+++ b/tests/run-make/suspicious-library/bar.rs
@@ -1,3 +1,5 @@
 extern crate foo;
 
-fn main() { foo::foo() }
+fn main() {
+    foo::foo()
+}
diff --git a/tests/run-make/symbol-mangling-hashed/a_dylib.rs b/tests/run-make/symbol-mangling-hashed/a_dylib.rs
index 8aec8fd82a5..49d65b72cac 100644
--- a/tests/run-make/symbol-mangling-hashed/a_dylib.rs
+++ b/tests/run-make/symbol-mangling-hashed/a_dylib.rs
@@ -1,4 +1,4 @@
-#![crate_type="dylib"]
+#![crate_type = "dylib"]
 pub fn hello() {
     println!("hello dylib");
 }
diff --git a/tests/run-make/symbol-mangling-hashed/a_rlib.rs b/tests/run-make/symbol-mangling-hashed/a_rlib.rs
index 873c86c5d0b..71e44ccc200 100644
--- a/tests/run-make/symbol-mangling-hashed/a_rlib.rs
+++ b/tests/run-make/symbol-mangling-hashed/a_rlib.rs
@@ -1,4 +1,4 @@
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 pub fn hello() {
     println!("hello rlib");
diff --git a/tests/run-make/symbol-mangling-hashed/b_bin.rs b/tests/run-make/symbol-mangling-hashed/b_bin.rs
index bcc53c37e12..8ee7fecda62 100644
--- a/tests/run-make/symbol-mangling-hashed/b_bin.rs
+++ b/tests/run-make/symbol-mangling-hashed/b_bin.rs
@@ -1,5 +1,5 @@
-extern crate a_rlib;
 extern crate a_dylib;
+extern crate a_rlib;
 extern crate b_dylib;
 
 fn main() {
diff --git a/tests/run-make/symbol-mangling-hashed/b_dylib.rs b/tests/run-make/symbol-mangling-hashed/b_dylib.rs
index c26a04b39ec..3252c9c75c2 100644
--- a/tests/run-make/symbol-mangling-hashed/b_dylib.rs
+++ b/tests/run-make/symbol-mangling-hashed/b_dylib.rs
@@ -1,7 +1,7 @@
-#![crate_type="dylib"]
+#![crate_type = "dylib"]
 
-extern crate a_rlib;
 extern crate a_dylib;
+extern crate a_rlib;
 
 pub fn hello() {
     a_rlib::hello();
diff --git a/tests/run-make/symbol-visibility/a_cdylib.rs b/tests/run-make/symbol-visibility/a_cdylib.rs
index d4fbff85bfe..cc034c8a31e 100644
--- a/tests/run-make/symbol-visibility/a_cdylib.rs
+++ b/tests/run-make/symbol-visibility/a_cdylib.rs
@@ -1,4 +1,4 @@
-#![crate_type="cdylib"]
+#![crate_type = "cdylib"]
 
 extern crate an_rlib;
 
diff --git a/tests/run-make/symbol-visibility/a_rust_dylib.rs b/tests/run-make/symbol-visibility/a_rust_dylib.rs
index a47df0ab7ee..22c0482343e 100644
--- a/tests/run-make/symbol-visibility/a_rust_dylib.rs
+++ b/tests/run-make/symbol-visibility/a_rust_dylib.rs
@@ -1,4 +1,4 @@
-#![crate_type="dylib"]
+#![crate_type = "dylib"]
 
 extern crate an_rlib;
 
@@ -12,4 +12,6 @@ pub extern "C" fn public_c_function_from_rust_dylib() {
 }
 
 // This should be exported if -Zshare-generics=yes
-pub fn public_generic_function_from_rust_dylib<T>(x: T) -> T { x }
+pub fn public_generic_function_from_rust_dylib<T>(x: T) -> T {
+    x
+}
diff --git a/tests/run-make/symbol-visibility/an_executable.rs b/tests/run-make/symbol-visibility/an_executable.rs
index 3f5e125ad19..945873bd9ce 100644
--- a/tests/run-make/symbol-visibility/an_executable.rs
+++ b/tests/run-make/symbol-visibility/an_executable.rs
@@ -1,4 +1,4 @@
-#![crate_type="bin"]
+#![crate_type = "bin"]
 
 extern crate an_rlib;
 
diff --git a/tests/run-make/symbol-visibility/an_rlib.rs b/tests/run-make/symbol-visibility/an_rlib.rs
index 3696422b11e..b291dbe571c 100644
--- a/tests/run-make/symbol-visibility/an_rlib.rs
+++ b/tests/run-make/symbol-visibility/an_rlib.rs
@@ -1,4 +1,4 @@
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 
 pub fn public_rust_function_from_rlib() {}
 
diff --git a/tests/run-make/symlinked-extern/bar.rs b/tests/run-make/symlinked-extern/bar.rs
index cd9c959d5e6..895582d5f13 100644
--- a/tests/run-make/symlinked-extern/bar.rs
+++ b/tests/run-make/symlinked-extern/bar.rs
@@ -2,5 +2,4 @@
 
 extern crate foo;
 
-pub fn bar(_s: foo::S) {
-}
+pub fn bar(_s: foo::S) {}
diff --git a/tests/run-make/symlinked-extern/foo.rs b/tests/run-make/symlinked-extern/foo.rs
index c00700b8cf8..4dcf6e135f6 100644
--- a/tests/run-make/symlinked-extern/foo.rs
+++ b/tests/run-make/symlinked-extern/foo.rs
@@ -2,4 +2,6 @@
 
 pub struct S;
 
-pub fn foo() -> S { S }
+pub fn foo() -> S {
+    S
+}
diff --git a/tests/run-make/target-cpu-native/foo.rs b/tests/run-make/target-cpu-native/foo.rs
index f79c691f085..f328e4d9d04 100644
--- a/tests/run-make/target-cpu-native/foo.rs
+++ b/tests/run-make/target-cpu-native/foo.rs
@@ -1,2 +1 @@
-fn main() {
-}
+fn main() {}
diff --git a/tests/run-make/test-harness/test-ignore-cfg.rs b/tests/run-make/test-harness/test-ignore-cfg.rs
index 31ef131f2ad..c6bd7680bd5 100644
--- a/tests/run-make/test-harness/test-ignore-cfg.rs
+++ b/tests/run-make/test-harness/test-ignore-cfg.rs
@@ -1,9 +1,7 @@
 #[test]
 #[cfg_attr(ignorecfg, ignore)]
-fn shouldignore() {
-}
+fn shouldignore() {}
 
 #[test]
 #[cfg_attr(noignorecfg, ignore)]
-fn shouldnotignore() {
-}
+fn shouldnotignore() {}
diff --git a/tests/run-make/type-mismatch-same-crate-name/crateA.rs b/tests/run-make/type-mismatch-same-crate-name/crateA.rs
index 4871c8c2e9c..0dccfbb4bed 100644
--- a/tests/run-make/type-mismatch-same-crate-name/crateA.rs
+++ b/tests/run-make/type-mismatch-same-crate-name/crateA.rs
@@ -3,7 +3,7 @@ mod foo {
 }
 
 mod bar {
-    pub trait Bar{}
+    pub trait Bar {}
 
     pub fn bar() -> Box<Bar> {
         unimplemented!()
@@ -12,5 +12,5 @@ pub fn bar() -> Box<Bar> {
 
 // This makes the publicly accessible path
 // differ from the internal one.
+pub use bar::{bar, Bar};
 pub use foo::Foo;
-pub use bar::{Bar, bar};
diff --git a/tests/run-make/type-mismatch-same-crate-name/crateB.rs b/tests/run-make/type-mismatch-same-crate-name/crateB.rs
index 24fcc7cadc1..e946c0ecac7 100644
--- a/tests/run-make/type-mismatch-same-crate-name/crateB.rs
+++ b/tests/run-make/type-mismatch-same-crate-name/crateB.rs
@@ -1,4 +1,4 @@
 extern crate crateA;
 
-pub fn try_foo(x: crateA::Foo){}
-pub fn try_bar(x: Box<crateA::Bar>){}
+pub fn try_foo(x: crateA::Foo) {}
+pub fn try_bar(x: Box<crateA::Bar>) {}
diff --git a/tests/run-make/use-suggestions-rust-2018/use-suggestions.rs b/tests/run-make/use-suggestions-rust-2018/use-suggestions.rs
index d262d6f9877..1bb987d0ebd 100644
--- a/tests/run-make/use-suggestions-rust-2018/use-suggestions.rs
+++ b/tests/run-make/use-suggestions-rust-2018/use-suggestions.rs
@@ -1,3 +1,3 @@
 fn main() {
-    let x = Baz{};
+    let x = Baz {};
 }
diff --git a/tests/run-make/wasm-custom-section/bar.rs b/tests/run-make/wasm-custom-section/bar.rs
index c95f3e1438b..1e94e99ff08 100644
--- a/tests/run-make/wasm-custom-section/bar.rs
+++ b/tests/run-make/wasm-custom-section/bar.rs
@@ -10,4 +10,4 @@
 pub static B: [u8; 2] = [7, 8];
 
 #[no_mangle]
-pub extern fn foo() {}
+pub extern "C" fn foo() {}
diff --git a/tests/run-make/wasm-custom-sections-opt/foo.rs b/tests/run-make/wasm-custom-sections-opt/foo.rs
index 9af7728b7f3..f521dd937a0 100644
--- a/tests/run-make/wasm-custom-sections-opt/foo.rs
+++ b/tests/run-make/wasm-custom-sections-opt/foo.rs
@@ -13,7 +13,7 @@ pub fn foo() {}
 }
 
 #[no_mangle]
-pub extern fn foo() {
+pub extern "C" fn foo() {
     // This will import `another::foo` through ThinLTO passes, and it better not
     // also accidentally import the `FOO` custom section into this module as
     // well
diff --git a/tests/run-make/wasm-exceptions-nostd/src/arena_alloc.rs b/tests/run-make/wasm-exceptions-nostd/src/arena_alloc.rs
index 572d253309c..12f1b4d8d12 100644
--- a/tests/run-make/wasm-exceptions-nostd/src/arena_alloc.rs
+++ b/tests/run-make/wasm-exceptions-nostd/src/arena_alloc.rs
@@ -14,9 +14,7 @@ pub struct ArenaAllocator {
 
 impl ArenaAllocator {
     pub const fn new() -> Self {
-        Self {
-            arena: UnsafeCell::new(Arena::new()),
-        }
+        Self { arena: UnsafeCell::new(Arena::new()) }
     }
 }
 
@@ -42,10 +40,7 @@ struct Arena {
 
 impl Arena {
     pub const fn new() -> Self {
-        Self {
-            buf: [0x55; ARENA_SIZE],
-            allocated: 0,
-        }
+        Self { buf: [0x55; ARENA_SIZE], allocated: 0 }
     }
 
     pub unsafe fn alloc(&mut self, layout: Layout) -> *mut u8 {
diff --git a/tests/run-make/wasm-exceptions-nostd/src/lib.rs b/tests/run-make/wasm-exceptions-nostd/src/lib.rs
index 9d336510469..3ea8797d3a6 100644
--- a/tests/run-make/wasm-exceptions-nostd/src/lib.rs
+++ b/tests/run-make/wasm-exceptions-nostd/src/lib.rs
@@ -1,9 +1,7 @@
 #![no_std]
 #![crate_type = "cdylib"]
-
 // Allow a few unstable features because we create a panic
 // runtime for native wasm exceptions from scratch
-
 #![feature(core_intrinsics)]
 #![feature(lang_items)]
 #![feature(link_llvm_intrinsics)]
@@ -39,20 +37,24 @@ pub extern "C" fn start() -> usize {
     let data = 0x1234usize as *mut u8; // Something to recognize
 
     unsafe {
-        core::intrinsics::catch_unwind(|data: *mut u8| {
-            let _log_on_drop = LogOnDrop;
+        core::intrinsics::catch_unwind(
+            |data: *mut u8| {
+                let _log_on_drop = LogOnDrop;
 
-            logging::log_str(&alloc::format!("`r#try` called with ptr {:?}", data));
-            let x = [12];
-            let _ = x[4]; // should panic
+                logging::log_str(&alloc::format!("`r#try` called with ptr {:?}", data));
+                let x = [12];
+                let _ = x[4]; // should panic
 
-            logging::log_str("This line should not be visible! :(");
-        }, data, |data, exception| {
-            let exception = *Box::from_raw(exception as *mut String);
-            logging::log_str("Caught something!");
-            logging::log_str(&alloc::format!("  data     : {:?}", data));
-            logging::log_str(&alloc::format!("  exception: {:?}", exception));
-        });
+                logging::log_str("This line should not be visible! :(");
+            },
+            data,
+            |data, exception| {
+                let exception = *Box::from_raw(exception as *mut String);
+                logging::log_str("Caught something!");
+                logging::log_str(&alloc::format!("  data     : {:?}", data));
+                logging::log_str(&alloc::format!("  exception: {:?}", exception));
+            },
+        );
     }
 
     logging::log_str("This program terminates correctly.");
diff --git a/tests/run-make/wasm-exceptions-nostd/src/panicking.rs b/tests/run-make/wasm-exceptions-nostd/src/panicking.rs
index 4a8923fd43d..52a32f3cd30 100644
--- a/tests/run-make/wasm-exceptions-nostd/src/panicking.rs
+++ b/tests/run-make/wasm-exceptions-nostd/src/panicking.rs
@@ -17,10 +17,7 @@ fn panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
     use alloc::boxed::Box;
     use alloc::string::ToString;
 
-    let msg = info
-        .message()
-        .map(|msg| msg.to_string())
-        .unwrap_or("(no message)".to_string());
+    let msg = info.message().map(|msg| msg.to_string()).unwrap_or("(no message)".to_string());
     let exception = Box::new(msg.to_string());
     unsafe {
         let exception_raw = Box::into_raw(exception);
diff --git a/tests/run-make/wasm-export-all-symbols/bar.rs b/tests/run-make/wasm-export-all-symbols/bar.rs
index ac9c20a57e5..039291f902e 100644
--- a/tests/run-make/wasm-export-all-symbols/bar.rs
+++ b/tests/run-make/wasm-export-all-symbols/bar.rs
@@ -1,7 +1,7 @@
 #![crate_type = "rlib"]
 
 #[no_mangle]
-pub extern fn foo() {}
+pub extern "C" fn foo() {}
 
 #[no_mangle]
 pub static FOO: u64 = 42;
diff --git a/tests/run-make/wasm-symbols-not-exported/bar.rs b/tests/run-make/wasm-symbols-not-exported/bar.rs
index 6ffbd3ec690..dd4d14416e7 100644
--- a/tests/run-make/wasm-symbols-not-exported/bar.rs
+++ b/tests/run-make/wasm-symbols-not-exported/bar.rs
@@ -11,15 +11,14 @@ unsafe fn alloc(&self, x: Layout) -> *mut u8 {
         1 as *mut u8
     }
 
-    unsafe fn dealloc(&self, ptr: *mut u8, x: Layout) {
-    }
+    unsafe fn dealloc(&self, ptr: *mut u8, x: Layout) {}
 }
 
 #[global_allocator]
 static A: B = B;
 
 #[no_mangle]
-pub extern fn foo(a: u32) -> u32 {
+pub extern "C" fn foo(a: u32) -> u32 {
     assert_eq!(a, 3);
     a * 2
 }
diff --git a/tests/run-make/wasm-symbols-not-exported/foo.rs b/tests/run-make/wasm-symbols-not-exported/foo.rs
index d46baee01b9..f85103f3535 100644
--- a/tests/run-make/wasm-symbols-not-exported/foo.rs
+++ b/tests/run-make/wasm-symbols-not-exported/foo.rs
@@ -1,7 +1,7 @@
 #![crate_type = "cdylib"]
 
 #[no_mangle]
-pub extern fn foo() {
+pub extern "C" fn foo() {
     println!("foo");
     panic!("test");
 }
diff --git a/tests/run-make/wasm-symbols-not-imported/foo.rs b/tests/run-make/wasm-symbols-not-imported/foo.rs
index b25bdc9800d..6af8d50a2ac 100644
--- a/tests/run-make/wasm-symbols-not-imported/foo.rs
+++ b/tests/run-make/wasm-symbols-not-imported/foo.rs
@@ -4,7 +4,7 @@
 use core::panic::PanicInfo;
 
 #[no_mangle]
-pub extern fn foo() {
+pub extern "C" fn foo() {
     panic!()
 }
 
diff --git a/tests/run-make/windows-spawn/spawn.rs b/tests/run-make/windows-spawn/spawn.rs
index a9e86d1577e..4afbaf876cd 100644
--- a/tests/run-make/windows-spawn/spawn.rs
+++ b/tests/run-make/windows-spawn/spawn.rs
@@ -6,5 +6,5 @@ fn main() {
     assert_eq!(
         Command::new("hopefullydoesntexist").arg("bar").spawn().unwrap_err().kind(),
         ErrorKind::NotFound
-    )
+    );
 }
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs
index 3a7aa1be868..f1fb5803948 100644
--- a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs
+++ b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs
@@ -1,17 +1,9 @@
 fn main() {
-    cc::Build::new()
-        .file("foo.c")
-        .compile("foo_c");
+    cc::Build::new().file("foo.c").compile("foo_c");
 
-    cc::Build::new()
-        .file("foo_asm.s")
-        .compile("foo_asm");
+    cc::Build::new().file("foo_asm.s").compile("foo_asm");
 
-    cc::Build::new()
-        .cpp(true)
-        .cpp_set_stdlib(None)
-        .file("foo_cxx.cpp")
-        .compile("foo_cxx");
+    cc::Build::new().cpp(true).cpp_set_stdlib(None).file("foo_cxx.cpp").compile("foo_cxx");
 
     // When the cmake crate detects the clang compiler, it passes the
     //  "--target" argument to the linker which subsequently fails. The
@@ -20,11 +12,11 @@ fn main() {
     //  `CMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY` can be used
     //  https://cmake.org/cmake/help/v3.5/module/CMakeForceCompiler.html
     let dst = cmake::Config::new("libcmake_foo")
-                .build_target("cmake_foo")
-                .define("CMAKE_C_COMPILER_FORCED", "1")
-                .define("CMAKE_CXX_COMPILER_FORCED", "1")
-                .define("CMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY", "1")
-                .build();
+        .build_target("cmake_foo")
+        .define("CMAKE_C_COMPILER_FORCED", "1")
+        .define("CMAKE_CXX_COMPILER_FORCED", "1")
+        .define("CMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY", "1")
+        .build();
     println!("cargo:rustc-link-search=native={}/build/", dst.display());
     println!("cargo:rustc-link-lib=static=cmake_foo");
 }