cleaned up some tests

19 files changed, 168 insertions, 108 deletions

diff --git a/tests/ui/allocator/allocator-reallocate-overflow.rs b/tests/ui/allocator/alloc-shrink-oob-read.rs
index 43810a469df..b9edfca3b7b 100644
--- a/tests/ui/allocator/allocator-reallocate-overflow.rs
+++ b/tests/ui/allocator/alloc-shrink-oob-read.rs
@@ -1,13 +1,13 @@
+//! Sanity check for out-of-bounds read caused by copying the entire original buffer on shrink.
+//!
+//! Regression test for: <https://github.com/rust-lang/rust/issues/16687>
+
 //@ run-pass
-// alloc::heap::reallocate test.
-//
-// Ideally this would be revised to use no_std, but for now it serves
-// well enough to reproduce (and illustrate) the bug from #16687.
 
 #![feature(allocator_api)]
 #![feature(slice_ptr_get)]
 
-use std::alloc::{handle_alloc_error, Allocator, Global, Layout};
+use std::alloc::{Allocator, Global, Layout, handle_alloc_error};
 use std::ptr::{self, NonNull};
 
 fn main() {
diff --git a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs
index 0172ca335c3..6d1c4c87fad 100644
--- a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs
+++ b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs
@@ -1,9 +1,9 @@
-// Ensure that auto trait checks `T` when it encounters a `PhantomData<T>` field, instead of
-// checking the `PhantomData<T>` type itself (which almost always implements an auto trait).
+//! Ensure that auto trait checks `T` when it encounters a `PhantomData<T>` field, instead of
+//! checking the `PhantomData<T>` type itself (which almost always implements an auto trait).
 
 #![feature(auto_traits)]
 
-use std::marker::{PhantomData};
+use std::marker::PhantomData;
 
 unsafe auto trait Zen {}
 
diff --git a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr
index ffd4c3a0e1a..56c2e8ff257 100644
--- a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr
+++ b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr
@@ -1,5 +1,5 @@
 error[E0277]: `T` cannot be shared between threads safely
-  --> $DIR/phantom-auto-trait.rs:21:12
+  --> $DIR/auto-trait-phantom-data-bounds.rs:21:12
    |
 LL |     is_zen(x)
    |     ------ ^ `T` cannot be shared between threads safely
@@ -7,19 +7,19 @@ LL |     is_zen(x)
    |     required by a bound introduced by this call
    |
 note: required for `&T` to implement `Zen`
-  --> $DIR/phantom-auto-trait.rs:10:24
+  --> $DIR/auto-trait-phantom-data-bounds.rs:10:24
    |
 LL | unsafe impl<'a, T: 'a> Zen for &'a T where T: Sync {}
    |                        ^^^     ^^^^^          ---- unsatisfied trait bound introduced here
 note: required because it appears within the type `PhantomData<&T>`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 note: required because it appears within the type `Guard<'_, T>`
-  --> $DIR/phantom-auto-trait.rs:12:8
+  --> $DIR/auto-trait-phantom-data-bounds.rs:12:8
    |
 LL | struct Guard<'a, T: 'a> {
    |        ^^^^^
 note: required by a bound in `is_zen`
-  --> $DIR/phantom-auto-trait.rs:18:14
+  --> $DIR/auto-trait-phantom-data-bounds.rs:18:14
    |
 LL | fn is_zen<T: Zen>(_: T) {}
    |              ^^^ required by this bound in `is_zen`
@@ -29,7 +29,7 @@ LL | fn not_sync<T: std::marker::Sync>(x: Guard<T>) {
    |              +++++++++++++++++++
 
 error[E0277]: `T` cannot be shared between threads safely
-  --> $DIR/phantom-auto-trait.rs:26:12
+  --> $DIR/auto-trait-phantom-data-bounds.rs:26:12
    |
 LL |     is_zen(x)
    |     ------ ^ `T` cannot be shared between threads safely
@@ -37,24 +37,24 @@ LL |     is_zen(x)
    |     required by a bound introduced by this call
    |
 note: required for `&T` to implement `Zen`
-  --> $DIR/phantom-auto-trait.rs:10:24
+  --> $DIR/auto-trait-phantom-data-bounds.rs:10:24
    |
 LL | unsafe impl<'a, T: 'a> Zen for &'a T where T: Sync {}
    |                        ^^^     ^^^^^          ---- unsatisfied trait bound introduced here
 note: required because it appears within the type `PhantomData<&T>`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 note: required because it appears within the type `Guard<'_, T>`
-  --> $DIR/phantom-auto-trait.rs:12:8
+  --> $DIR/auto-trait-phantom-data-bounds.rs:12:8
    |
 LL | struct Guard<'a, T: 'a> {
    |        ^^^^^
 note: required because it appears within the type `Nested<Guard<'_, T>>`
-  --> $DIR/phantom-auto-trait.rs:16:8
+  --> $DIR/auto-trait-phantom-data-bounds.rs:16:8
    |
 LL | struct Nested<T>(T);
    |        ^^^^^^
 note: required by a bound in `is_zen`
-  --> $DIR/phantom-auto-trait.rs:18:14
+  --> $DIR/auto-trait-phantom-data-bounds.rs:18:14
    |
 LL | fn is_zen<T: Zen>(_: T) {}
    |              ^^^ required by this bound in `is_zen`
diff --git a/tests/ui/binop/binop-evaluation-order-primitive.rs b/tests/ui/binop/binop-evaluation-order-primitive.rs
index d988e2ed14f..33266d1c047 100644
--- a/tests/ui/binop/binop-evaluation-order-primitive.rs
+++ b/tests/ui/binop/binop-evaluation-order-primitive.rs
@@ -1,6 +1,15 @@
+//! Test evaluation order in binary operations with primitive types.
+
 //@ run-pass
 
 fn main() {
     let x = Box::new(0);
-    assert_eq!(0, *x + { drop(x); let _ = Box::new(main); 0 });
+    assert_eq!(
+        0,
+        *x + {
+            drop(x);
+            let _ = Box::new(main);
+            0
+        }
+    );
 }
diff --git a/tests/ui/coercion/basic-ptr-coercions.rs b/tests/ui/coercion/basic-ptr-coercions.rs
index 8cc4120328e..4229d1fb274 100644
--- a/tests/ui/coercion/basic-ptr-coercions.rs
+++ b/tests/ui/coercion/basic-ptr-coercions.rs
@@ -1,29 +1,24 @@
-//@ run-pass
-
-#![allow(unused_variables)]
-// Test coercions between pointers which don't do anything fancy like unsizing.
+//! Tests basic pointer coercions
 
+//@ run-pass
 
 pub fn main() {
     // &mut -> &
     let x: &mut isize = &mut 42;
-    let x: &isize = x;
-
-    let x: &isize = &mut 42;
+    let _x: &isize = x;
+    let _x: &isize = &mut 42;
 
     // & -> *const
     let x: &isize = &42;
-    let x: *const isize = x;
-
-    let x: *const isize = &42;
+    let _x: *const isize = x;
+    let _x: *const isize = &42;
 
     // &mut -> *const
     let x: &mut isize = &mut 42;
-    let x: *const isize = x;
-
-    let x: *const isize = &mut 42;
+    let _x: *const isize = x;
+    let _x: *const isize = &mut 42;
 
     // *mut -> *const
-    let x: *mut isize = &mut 42;
-    let x: *const isize = x;
+    let _x: *mut isize = &mut 42;
+    let _x: *const isize = x;
 }
diff --git a/tests/ui/coercion/ptr-mutability-errors.rs b/tests/ui/coercion/ptr-mutability-errors.rs
index 2549bd6f134..391eaf0b913 100644
--- a/tests/ui/coercion/ptr-mutability-errors.rs
+++ b/tests/ui/coercion/ptr-mutability-errors.rs
@@ -1,5 +1,4 @@
-// Test coercions between pointers which don't do anything fancy like unsizing.
-// These are testing that we don't lose mutability when converting to raw pointers.
+//! Tests that pointer coercions preserving mutability are enforced:
 
 //@ dont-require-annotations: NOTE
 
diff --git a/tests/ui/coercion/ptr-mutability-errors.stderr b/tests/ui/coercion/ptr-mutability-errors.stderr
index 8de41d2c382..b4ded821c79 100644
--- a/tests/ui/coercion/ptr-mutability-errors.stderr
+++ b/tests/ui/coercion/ptr-mutability-errors.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/ptr-coercion.rs:9:25
+  --> $DIR/ptr-mutability-errors.rs:8:25
    |
 LL |     let x: *mut isize = x;
    |            ----------   ^ types differ in mutability
@@ -10,7 +10,7 @@ LL |     let x: *mut isize = x;
               found raw pointer `*const isize`
 
 error[E0308]: mismatched types
-  --> $DIR/ptr-coercion.rs:15:25
+  --> $DIR/ptr-mutability-errors.rs:14:25
    |
 LL |     let x: *mut isize = &42;
    |            ----------   ^^^ types differ in mutability
@@ -21,7 +21,7 @@ LL |     let x: *mut isize = &42;
                 found reference `&isize`
 
 error[E0308]: mismatched types
-  --> $DIR/ptr-coercion.rs:21:25
+  --> $DIR/ptr-mutability-errors.rs:20:25
    |
 LL |     let x: *mut isize = x;
    |            ----------   ^ types differ in mutability
diff --git a/tests/ui/io-checks/stdout-stderr-separation.rs b/tests/ui/io-checks/stdout-stderr-separation.rs
index 4b356e2fe61..1bb3f16d3a1 100644
--- a/tests/ui/io-checks/stdout-stderr-separation.rs
+++ b/tests/ui/io-checks/stdout-stderr-separation.rs
@@ -1,3 +1,6 @@
+//! Test that print!/println! output to stdout and eprint!/eprintln!
+//! output to stderr correctly.
+
 //@ run-pass
 //@ needs-subprocess
 
diff --git a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs
index d5f43df9d85..1cd41114bbd 100644
--- a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs
+++ b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs
@@ -1,13 +1,25 @@
+//! Test closure parameter type inference and type mismatch errors.
+//!
+//! Related to <https://github.com/rust-lang/rust/issues/2093>.
+
 //@ dont-require-annotations: NOTE
 
-fn let_in<T, F>(x: T, f: F) where F: FnOnce(T) {}
+fn let_in<T, F>(x: T, f: F)
+where
+    F: FnOnce(T),
+{
+}
 
 fn main() {
-    let_in(3u32, |i| { assert!(i == 3i32); });
-    //~^ ERROR mismatched types
-    //~| NOTE expected `u32`, found `i32`
+    let_in(3u32, |i| {
+        assert!(i == 3i32);
+        //~^ ERROR mismatched types
+        //~| NOTE expected `u32`, found `i32`
+    });
 
-    let_in(3i32, |i| { assert!(i == 3u32); });
-    //~^ ERROR mismatched types
-    //~| NOTE expected `i32`, found `u32`
+    let_in(3i32, |i| {
+        assert!(i == 3u32);
+        //~^ ERROR mismatched types
+        //~| NOTE expected `i32`, found `u32`
+    });
 }
diff --git a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr
index a6d673e61c6..c75e90ce4ef 100644
--- a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr
+++ b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr
@@ -1,29 +1,29 @@
 error[E0308]: mismatched types
-  --> $DIR/pptypedef.rs:6:37
+  --> $DIR/closure-parameter-type-inference-mismatch.rs:15:22
    |
-LL |     let_in(3u32, |i| { assert!(i == 3i32); });
-   |                                -    ^^^^ expected `u32`, found `i32`
-   |                                |
-   |                                expected because this is `u32`
+LL |         assert!(i == 3i32);
+   |                 -    ^^^^ expected `u32`, found `i32`
+   |                 |
+   |                 expected because this is `u32`
    |
 help: change the type of the numeric literal from `i32` to `u32`
    |
-LL -     let_in(3u32, |i| { assert!(i == 3i32); });
-LL +     let_in(3u32, |i| { assert!(i == 3u32); });
+LL -         assert!(i == 3i32);
+LL +         assert!(i == 3u32);
    |
 
 error[E0308]: mismatched types
-  --> $DIR/pptypedef.rs:10:37
+  --> $DIR/closure-parameter-type-inference-mismatch.rs:21:22
    |
-LL |     let_in(3i32, |i| { assert!(i == 3u32); });
-   |                                -    ^^^^ expected `i32`, found `u32`
-   |                                |
-   |                                expected because this is `i32`
+LL |         assert!(i == 3u32);
+   |                 -    ^^^^ expected `i32`, found `u32`
+   |                 |
+   |                 expected because this is `i32`
    |
 help: change the type of the numeric literal from `u32` to `i32`
    |
-LL -     let_in(3i32, |i| { assert!(i == 3u32); });
-LL +     let_in(3i32, |i| { assert!(i == 3i32); });
+LL -         assert!(i == 3u32);
+LL +         assert!(i == 3i32);
    |
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs
index 50f1fe873cb..6711d303eb3 100644
--- a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs
+++ b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs
@@ -1,4 +1,8 @@
-fn unrelated() -> Result<(), std::string::ParseError> {  // #57664
+//! Regression test for <https://github.com/rust-lang/rust/issues/57664>.
+//! Checks that compiler doesn't get confused by `?` operator and complex
+//! return types when reporting type mismatches.
+
+fn unrelated() -> Result<(), std::string::ParseError> {
     let x = 0;
 
     match x {
diff --git a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr
index 34aaea5b70b..38392fe99d6 100644
--- a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr
+++ b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/point-to-type-err-cause-on-impl-trait-return-2.rs:9:41
+  --> $DIR/type-error-diagnostic-in-complex-return.rs:13:41
    |
 LL |             let value: &bool = unsafe { &42 };
    |                                         ^^^ expected `&bool`, found `&{integer}`
diff --git a/tests/ui/parser/doc-comment-in-generic.rs b/tests/ui/parser/doc-comment-in-generic.rs
index 84abe875910..2596496763b 100644
--- a/tests/ui/parser/doc-comment-in-generic.rs
+++ b/tests/ui/parser/doc-comment-in-generic.rs
@@ -1,9 +1,13 @@
+//! Tests correct parsing of doc comments on generic parameters in traits.
+//! Checks that compiler doesn't panic when processing this.
+
 //@ check-pass
-// Check that it doesn't panic when `Input` gets its visibility checked.
 
 #![crate_type = "lib"]
 
 pub trait Layer<
-    /// Hello.
+    /// Documentation for generic parameter.
     Input,
-> {}
+>
+{
+}
diff --git a/tests/ui/parser/raw/raw-string-literals.rs b/tests/ui/parser/raw/raw-string-literals.rs
index 23018403295..2272f268b36 100644
--- a/tests/ui/parser/raw/raw-string-literals.rs
+++ b/tests/ui/parser/raw/raw-string-literals.rs
Binary files differdiff --git a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs
index d6d41e959d9..42b0b9ac44d 100644
--- a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs
+++ b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs
@@ -1,16 +1,24 @@
-// Tests how we behave when the user attempts to mutate an immutable
-// binding that was introduced by either `ref` or `ref mut`
-// patterns.
-//
-// Such bindings cannot be made mutable via the mere addition of the
-// `mut` keyword, and thus we want to check that the compiler does not
-// suggest doing so.
+//! Tests how we behave when the user attempts to mutate an immutable
+//! binding that was introduced by either `ref` or `ref mut`
+//! patterns.
+//!
+//! Such bindings cannot be made mutable via the mere addition of the
+//! `mut` keyword, and thus we want to check that the compiler does not
+//! suggest doing so.
 
 fn main() {
     let (mut one_two, mut three_four) = ((1, 2), (3, 4));
+
+    // Bind via pattern:
+    // - `a` as immutable reference (`ref`)
+    // - `b` as mutable reference (`ref mut`)
     let &mut (ref a, ref mut b) = &mut one_two;
+
+    // Attempt to reassign immutable `ref`-bound variable
     a = &three_four.0;
-    //~^ ERROR cannot assign twice to immutable variable `a` [E0384]
+    //~^ ERROR cannot assign twice to immutable variable `a`
+
+    // Attempt to reassign mutable `ref mut`-bound variable
     b = &mut three_four.1;
-    //~^ ERROR cannot assign twice to immutable variable `b` [E0384]
+    //~^ ERROR cannot assign twice to immutable variable `b`
 }
diff --git a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr
index e623578e025..e04eb1dd25c 100644
--- a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr
+++ b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr
@@ -1,13 +1,14 @@
 error[E0384]: cannot assign twice to immutable variable `a`
-  --> $DIR/reassign-ref-mut.rs:12:5
+  --> $DIR/pattern-ref-bindings-reassignment.rs:18:5
    |
 LL |     let &mut (ref a, ref mut b) = &mut one_two;
    |               ----- first assignment to `a`
+...
 LL |     a = &three_four.0;
    |     ^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable
 
 error[E0384]: cannot assign twice to immutable variable `b`
-  --> $DIR/reassign-ref-mut.rs:14:5
+  --> $DIR/pattern-ref-bindings-reassignment.rs:22:5
    |
 LL |     let &mut (ref a, ref mut b) = &mut one_two;
    |                      --------- first assignment to `b`
diff --git a/tests/ui/print-request/print-calling-conventions.rs b/tests/ui/print-request/print-calling-conventions.rs
index 302ed088142..cefaa0d9b6f 100644
--- a/tests/ui/print-request/print-calling-conventions.rs
+++ b/tests/ui/print-request/print-calling-conventions.rs
@@ -1,2 +1,4 @@
+//! Test that `--print calling-conventions` outputs all supported calling conventions.
+
 //@ compile-flags: --print calling-conventions
 //@ build-pass
diff --git a/tests/ui/std/fs-nul-byte-paths.rs b/tests/ui/std/fs-nul-byte-paths.rs
index 5c37980127d..79012362347 100644
--- a/tests/ui/std/fs-nul-byte-paths.rs
+++ b/tests/ui/std/fs-nul-byte-paths.rs
@@ -1,18 +1,22 @@
-//@ run-pass
+//! Test that `std::fs` functions properly reject paths containing NUL bytes.
 
+//@ run-pass
 #![allow(deprecated)]
 //@ ignore-wasm32 no cwd
 //@ ignore-sgx no files
 
-use std::fs;
-use std::io;
+use std::{fs, io};
 
 fn assert_invalid_input<T>(on: &str, result: io::Result<T>) {
     fn inner(on: &str, result: io::Result<()>) {
         match result {
             Ok(()) => panic!("{} didn't return an error on a path with NUL", on),
-            Err(e) => assert!(e.kind() == io::ErrorKind::InvalidInput,
-                              "{} returned a strange {:?} on a path with NUL", on, e.kind()),
+            Err(e) => assert!(
+                e.kind() == io::ErrorKind::InvalidInput,
+                "{} returned a strange {:?} on a path with NUL",
+                on,
+                e.kind()
+            ),
         }
     }
     inner(on, result.map(drop))
@@ -43,6 +47,8 @@ fn main() {
     assert_invalid_input("remove_dir", fs::remove_dir("\0"));
     assert_invalid_input("remove_dir_all", fs::remove_dir_all("\0"));
     assert_invalid_input("read_dir", fs::read_dir("\0"));
-    assert_invalid_input("set_permissions",
-                         fs::set_permissions("\0", fs::metadata(".").unwrap().permissions()));
+    assert_invalid_input(
+        "set_permissions",
+        fs::set_permissions("\0", fs::metadata(".").unwrap().permissions()),
+    );
 }
diff --git a/tests/ui/typeck/nested-generic-traits-performance.rs b/tests/ui/typeck/nested-generic-traits-performance.rs
index 29c278171a6..e029228c1b2 100644
--- a/tests/ui/typeck/nested-generic-traits-performance.rs
+++ b/tests/ui/typeck/nested-generic-traits-performance.rs
@@ -1,65 +1,82 @@
+//! Test that deeply nested generic traits with complex bounds
+//! don't cause excessive memory usage during type checking.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/31849>.
+
 //@ run-pass
-// Regression test for #31849: the problem here was actually a performance
-// cliff, but I'm adding the test for reference.
 
 pub trait Upcast<T> {
     fn upcast(self) -> T;
 }
 
-impl<S1, S2, T1, T2> Upcast<(T1, T2)> for (S1,S2)
-    where S1: Upcast<T1>,
-          S2: Upcast<T2>,
+impl<S1, S2, T1, T2> Upcast<(T1, T2)> for (S1, S2)
+where
+    S1: Upcast<T1>,
+    S2: Upcast<T2>,
 {
-    fn upcast(self) -> (T1, T2) { (self.0.upcast(), self.1.upcast()) }
+    fn upcast(self) -> (T1, T2) {
+        (self.0.upcast(), self.1.upcast())
+    }
 }
 
-impl Upcast<()> for ()
-{
-    fn upcast(self) -> () { () }
+impl Upcast<()> for () {
+    fn upcast(self) -> () {
+        ()
+    }
 }
 
 pub trait ToStatic {
     type Static: 'static;
-    fn to_static(self) -> Self::Static where Self: Sized;
+    fn to_static(self) -> Self::Static
+    where
+        Self: Sized;
 }
 
 impl<T, U> ToStatic for (T, U)
-    where T: ToStatic,
-          U: ToStatic
+where
+    T: ToStatic,
+    U: ToStatic,
 {
     type Static = (T::Static, U::Static);
-    fn to_static(self) -> Self::Static { (self.0.to_static(), self.1.to_static()) }
+    fn to_static(self) -> Self::Static {
+        (self.0.to_static(), self.1.to_static())
+    }
 }
 
-impl ToStatic for ()
-{
+impl ToStatic for () {
     type Static = ();
-    fn to_static(self) -> () { () }
+    fn to_static(self) -> () {
+        ()
+    }
 }
 
-
 trait Factory {
     type Output;
     fn build(&self) -> Self::Output;
 }
 
-impl<S,T> Factory for (S, T)
-    where S: Factory,
-          T: Factory,
-          S::Output: ToStatic,
-          <S::Output as ToStatic>::Static: Upcast<S::Output>,
+impl<S, T> Factory for (S, T)
+where
+    S: Factory,
+    T: Factory,
+    S::Output: ToStatic,
+    <S::Output as ToStatic>::Static: Upcast<S::Output>,
 {
     type Output = (S::Output, T::Output);
-    fn build(&self) -> Self::Output { (self.0.build().to_static().upcast(), self.1.build()) }
+    fn build(&self) -> Self::Output {
+        (self.0.build().to_static().upcast(), self.1.build())
+    }
 }
 
 impl Factory for () {
     type Output = ();
-    fn build(&self) -> Self::Output { () }
+    fn build(&self) -> Self::Output {
+        ()
+    }
 }
 
 fn main() {
-    // More parens, more time.
-    let it = ((((((((((),()),()),()),()),()),()),()),()),());
+    // Deeply nested tuple to trigger the original performance issue
+    let it = ((((((((((), ()), ()), ()), ()), ()), ()), ()), ()), ());
     it.build();
 }