Auto merge of #145407 - Kobzol:rollup-g6yhx82, r=Kobzol

Rollup of 11 pull requests

Successful merges:

 - rust-lang/rust#137872 (Include whitespace in "remove |" suggestion and make it hidden)
 - rust-lang/rust#144631 (Fix test intrinsic-raw_eq-const-bad for big-endian)
 - rust-lang/rust#145233 (cfg_select: Support unbraced expressions)
 - rust-lang/rust#145261 (Improve tracing in bootstrap)
 - rust-lang/rust#145324 (Rename and document `ONLY_HOSTS` in bootstrap)
 - rust-lang/rust#145353 (bootstrap: Fix jemalloc 64K page support for aarch64 tools)
 - rust-lang/rust#145379 (bootstrap: Support passing `--timings` to cargo)
 - rust-lang/rust#145397 (Rust documentation, use `rustc-dev-guide` :3)
 - rust-lang/rust#145398 (Use `default_field_values` in `Resolver`)
 - rust-lang/rust#145401 (cleanup: Remove useless `[T].iter().last()`)
 - rust-lang/rust#145403 (Adjust error message grammar to be less awkward)

r? `@ghost`
`@rustbot` modify labels: rollup

26 files changed, 156 insertions, 196 deletions

diff --git a/tests/ui/borrowck/borrowck-in-static.stderr b/tests/ui/borrowck/borrowck-in-static.stderr
index d85f6f5fdd5..32419da0ce2 100644
--- a/tests/ui/borrowck/borrowck-in-static.stderr
+++ b/tests/ui/borrowck/borrowck-in-static.stderr
@@ -10,7 +10,7 @@ LL |     Box::new(|| x)
    |              |
    |              captured by this `Fn` closure
    |
-   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
 help: consider cloning the value if the performance cost is acceptable
    |
 LL |     Box::new(|| x.clone())
diff --git a/tests/ui/borrowck/borrowck-move-by-capture.stderr b/tests/ui/borrowck/borrowck-move-by-capture.stderr
index e9e05440766..0ace6156281 100644
--- a/tests/ui/borrowck/borrowck-move-by-capture.stderr
+++ b/tests/ui/borrowck/borrowck-move-by-capture.stderr
@@ -12,7 +12,7 @@ LL |         let _h = to_fn_once(move || -> isize { *bar });
    |                             |
    |                             `bar` is moved here
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/borrowck-move-by-capture.rs:3:37
    |
 LL | fn to_fn_mut<A:std::marker::Tuple,F:FnMut<A>>(f: F) -> F { f }
diff --git a/tests/ui/borrowck/issue-103624.stderr b/tests/ui/borrowck/issue-103624.stderr
index ef022808886..bd6c1c44bfb 100644
--- a/tests/ui/borrowck/issue-103624.stderr
+++ b/tests/ui/borrowck/issue-103624.stderr
@@ -13,7 +13,7 @@ LL |
 LL |             self.b;
    |             ^^^^^^ `self.b` is moved here
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/issue-103624.rs:7:36
    |
 LL | async fn spawn_blocking<T>(f: impl (Fn() -> T) + Send + Sync + 'static) -> T {
diff --git a/tests/ui/borrowck/issue-87456-point-to-closure.stderr b/tests/ui/borrowck/issue-87456-point-to-closure.stderr
index 043e336cd86..c31d096109c 100644
--- a/tests/ui/borrowck/issue-87456-point-to-closure.stderr
+++ b/tests/ui/borrowck/issue-87456-point-to-closure.stderr
@@ -10,7 +10,7 @@ LL |
 LL |         let _foo: String = val;
    |                            ^^^ move occurs because `val` has type `String`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/issue-87456-point-to-closure.rs:3:24
    |
 LL | fn take_mut(_val: impl FnMut()) {}
diff --git a/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr b/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr
index d3333041310..69c36674916 100644
--- a/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr
+++ b/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr
@@ -10,7 +10,7 @@ LL |         y.into_iter();
    |         |
    |         move occurs because `y` has type `Vec<String>`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/unboxed-closures-move-upvar-from-non-once-ref-closure.rs:5:28
    |
 LL | fn call<F>(f: F) where F : Fn() {
diff --git a/tests/ui/consts/const-eval/union-const-eval-field.rs b/tests/ui/consts/const-eval/union-const-eval-field.rs
index 719e59b007c..2c9061a7a50 100644
--- a/tests/ui/consts/const-eval/union-const-eval-field.rs
+++ b/tests/ui/consts/const-eval/union-const-eval-field.rs
@@ -1,5 +1,6 @@
 //@ dont-require-annotations: NOTE
 //@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([[:xdigit:]]{2}\s){4}(__\s){4}\s+│\s+([?|\.]){4}\W{4}" -> "HEX_DUMP"
 
 type Field1 = i32;
 type Field2 = f32;
diff --git a/tests/ui/consts/const-eval/union-const-eval-field.stderr b/tests/ui/consts/const-eval/union-const-eval-field.stderr
index 1843ce273ac..3b7e5508d56 100644
--- a/tests/ui/consts/const-eval/union-const-eval-field.stderr
+++ b/tests/ui/consts/const-eval/union-const-eval-field.stderr
@@ -1,21 +1,21 @@
 error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
-  --> $DIR/union-const-eval-field.rs:29:37
+  --> $DIR/union-const-eval-field.rs:30:37
    |
 LL |     const FIELD3: Field3 = unsafe { UNION.field3 };
    |                                     ^^^^^^^^^^^^ evaluation of `read_field3::FIELD3` failed here
    |
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
-               00 00 80 3f __ __ __ __                         │ ...?░░░░
+               HEX_DUMP
            }
 
 note: erroneous constant encountered
-  --> $DIR/union-const-eval-field.rs:31:5
+  --> $DIR/union-const-eval-field.rs:32:5
    |
 LL |     FIELD3
    |     ^^^^^^
 
 note: erroneous constant encountered
-  --> $DIR/union-const-eval-field.rs:31:5
+  --> $DIR/union-const-eval-field.rs:32:5
    |
 LL |     FIELD3
    |     ^^^^^^
diff --git a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
index 15f4a9a778e..ed15f5bba96 100644
--- a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
+++ b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
@@ -1,3 +1,4 @@
+//@ normalize-stderr: "[[:xdigit:]]{2} __ ([[:xdigit:]]{2}\s){2}" -> "HEX_DUMP"
 #![feature(core_intrinsics)]
 
 const RAW_EQ_PADDING: bool = unsafe {
diff --git a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
index 5f4ef14d586..329da35297e 100644
--- a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
+++ b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
@@ -1,15 +1,15 @@
 error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at [0x1..0x2], and this operation requires initialized memory
-  --> $DIR/intrinsic-raw_eq-const-bad.rs:4:5
+  --> $DIR/intrinsic-raw_eq-const-bad.rs:5:5
    |
 LL |     std::intrinsics::raw_eq(&(1_u8, 2_u16), &(1_u8, 2_u16))
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `RAW_EQ_PADDING` failed here
    |
    = note: the raw bytes of the constant (size: 4, align: 2) {
-               01 __ 02 00                                     │ .░..
+               HEX_DUMP                                    │ .░..
            }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/intrinsic-raw_eq-const-bad.rs:9:5
+  --> $DIR/intrinsic-raw_eq-const-bad.rs:10:5
    |
 LL |     std::intrinsics::raw_eq(&(&0), &(&1))
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `RAW_EQ_PTR` failed here
@@ -18,7 +18,7 @@ LL |     std::intrinsics::raw_eq(&(&0), &(&1))
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: accessing memory with alignment 1, but alignment 4 is required
-  --> $DIR/intrinsic-raw_eq-const-bad.rs:16:5
+  --> $DIR/intrinsic-raw_eq-const-bad.rs:17:5
    |
 LL |     std::intrinsics::raw_eq(aref, aref)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `RAW_EQ_NOT_ALIGNED` failed here
diff --git a/tests/ui/issues/issue-4335.stderr b/tests/ui/issues/issue-4335.stderr
index b6d8f086163..d1a64e3dd46 100644
--- a/tests/ui/issues/issue-4335.stderr
+++ b/tests/ui/issues/issue-4335.stderr
@@ -10,7 +10,7 @@ LL |     id(Box::new(|| *v))
    |                 |
    |                 captured by this `FnMut` closure
    |
-   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
 help: if `T` implemented `Clone`, you could clone the value
   --> $DIR/issue-4335.rs:5:10
    |
diff --git a/tests/ui/macros/cfg_select.rs b/tests/ui/macros/cfg_select.rs
index 461d2e0e8c1..9241141ef9a 100644
--- a/tests/ui/macros/cfg_select.rs
+++ b/tests/ui/macros/cfg_select.rs
@@ -8,10 +8,42 @@ fn print() {
     });
 }
 
-fn arm_rhs_must_be_in_braces() -> i32 {
+fn print_2() {
+    println!(cfg_select! {
+        unix => "unix",
+        _ => "not unix",
+    });
+}
+
+fn arm_rhs_expr_1() -> i32 {
     cfg_select! {
         true => 1
-        //~^ ERROR: expected `{`, found `1`
+    }
+}
+
+fn arm_rhs_expr_2() -> i32 {
+    cfg_select! {
+        true => 1,
+        false => 2
+    }
+}
+
+fn arm_rhs_expr_3() -> i32 {
+    cfg_select! {
+        true => 1,
+        false => 2,
+        true => { 42 }
+        false => -1 as i32,
+        true => 2 + 2,
+        false => "",
+        true => if true { 42 } else { 84 }
+        false => if true { 42 } else { 84 },
+        true => return 42,
+        false => loop {}
+        true => (1, 2),
+        false => (1, 2,),
+        true => todo!(),
+        false => println!("hello"),
     }
 }
 
diff --git a/tests/ui/macros/cfg_select.stderr b/tests/ui/macros/cfg_select.stderr
index 6c18a7c189d..7280f35c16f 100644
--- a/tests/ui/macros/cfg_select.stderr
+++ b/tests/ui/macros/cfg_select.stderr
@@ -1,11 +1,5 @@
-error: expected `{`, found `1`
-  --> $DIR/cfg_select.rs:13:17
-   |
-LL |         true => 1
-   |                 ^ expected `{`
-
 warning: unreachable predicate
-  --> $DIR/cfg_select.rs:20:5
+  --> $DIR/cfg_select.rs:52:5
    |
 LL |     _ => {}
    |     - always matches
@@ -13,7 +7,7 @@ LL |     true => {}
    |     ^^^^ this predicate is never reached
 
 error: none of the predicates in this `cfg_select` evaluated to true
-  --> $DIR/cfg_select.rs:24:1
+  --> $DIR/cfg_select.rs:56:1
    |
 LL | / cfg_select! {
 LL | |
@@ -22,10 +16,10 @@ LL | | }
    | |_^
 
 error: none of the predicates in this `cfg_select` evaluated to true
-  --> $DIR/cfg_select.rs:29:1
+  --> $DIR/cfg_select.rs:61:1
    |
 LL | cfg_select! {}
    | ^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 2 previous errors; 1 warning emitted
 
diff --git a/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
index dfc983bf487..e2aa5718cb6 100644
--- a/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
+++ b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
@@ -10,7 +10,7 @@ LL |     let _f = to_fn(|| test(i));
    |                    |
    |                    captured by this `Fn` closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/moves-based-on-type-move-out-of-closure-env-issue-1965.rs:3:33
    |
 LL | fn to_fn<A:std::marker::Tuple,F:Fn<A>>(f: F) -> F { f }
diff --git a/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr b/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr
index 7f9a8e50dae..4749e3b8e45 100644
--- a/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr
+++ b/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr
@@ -10,7 +10,7 @@ LL |        expect_fn(|| drop(x.0));
    |                  |
    |                  captured by this `Fn` closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/issue-52663-span-decl-captured-variable.rs:1:33
    |
 LL | fn expect_fn<F>(f: F) where F : Fn() {
diff --git a/tests/ui/or-patterns/issue-64879-trailing-before-guard.fixed b/tests/ui/or-patterns/issue-64879-trailing-before-guard.fixed
new file mode 100644
index 00000000000..0c65f709d66
--- /dev/null
+++ b/tests/ui/or-patterns/issue-64879-trailing-before-guard.fixed
@@ -0,0 +1,18 @@
+// In this regression test we check that a trailing `|` in an or-pattern just
+// before the `if` token of a `match` guard will receive parser recovery with
+// an appropriate error message.
+//@ run-rustfix
+#![allow(dead_code)]
+
+enum E { A, B }
+
+fn main() {
+    match E::A {
+        E::A |
+        E::B //~ ERROR a trailing `|` is not allowed in an or-pattern
+        if true => {
+            let _recovery_witness: i32 = 0i32; //~ ERROR mismatched types
+        }
+        _ => {}
+    }
+}
diff --git a/tests/ui/or-patterns/issue-64879-trailing-before-guard.rs b/tests/ui/or-patterns/issue-64879-trailing-before-guard.rs
index 181c770096a..d7da564c2e1 100644
--- a/tests/ui/or-patterns/issue-64879-trailing-before-guard.rs
+++ b/tests/ui/or-patterns/issue-64879-trailing-before-guard.rs
@@ -1,6 +1,8 @@
 // In this regression test we check that a trailing `|` in an or-pattern just
 // before the `if` token of a `match` guard will receive parser recovery with
 // an appropriate error message.
+//@ run-rustfix
+#![allow(dead_code)]
 
 enum E { A, B }
 
@@ -9,7 +11,8 @@ fn main() {
         E::A |
         E::B | //~ ERROR a trailing `|` is not allowed in an or-pattern
         if true => {
-            let recovery_witness: bool = 0; //~ ERROR mismatched types
+            let _recovery_witness: i32 = 0u32; //~ ERROR mismatched types
         }
+        _ => {}
     }
 }
diff --git a/tests/ui/or-patterns/issue-64879-trailing-before-guard.stderr b/tests/ui/or-patterns/issue-64879-trailing-before-guard.stderr
index 91db3d049f6..238c76080dc 100644
--- a/tests/ui/or-patterns/issue-64879-trailing-before-guard.stderr
+++ b/tests/ui/or-patterns/issue-64879-trailing-before-guard.stderr
@@ -1,24 +1,24 @@
 error: a trailing `|` is not allowed in an or-pattern
-  --> $DIR/issue-64879-trailing-before-guard.rs:10:14
+  --> $DIR/issue-64879-trailing-before-guard.rs:12:14
    |
 LL |         E::A |
    |         ---- while parsing this or-pattern starting here
 LL |         E::B |
    |              ^
+
+error[E0308]: mismatched types
+  --> $DIR/issue-64879-trailing-before-guard.rs:14:42
    |
-help: remove the `|`
+LL |             let _recovery_witness: i32 = 0u32;
+   |                                    ---   ^^^^ expected `i32`, found `u32`
+   |                                    |
+   |                                    expected due to this
    |
-LL -         E::B |
-LL +         E::B
+help: change the type of the numeric literal from `u32` to `i32`
    |
-
-error[E0308]: mismatched types
-  --> $DIR/issue-64879-trailing-before-guard.rs:12:42
+LL -             let _recovery_witness: i32 = 0u32;
+LL +             let _recovery_witness: i32 = 0i32;
    |
-LL |             let recovery_witness: bool = 0;
-   |                                   ----   ^ expected `bool`, found integer
-   |                                   |
-   |                                   expected due to this
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/or-patterns/remove-leading-vert.fixed b/tests/ui/or-patterns/remove-leading-vert.fixed
index 2851b8f18c5..aa7975dc508 100644
--- a/tests/ui/or-patterns/remove-leading-vert.fixed
+++ b/tests/ui/or-patterns/remove-leading-vert.fixed
@@ -23,26 +23,26 @@ fn leading() {
 
 #[cfg(false)]
 fn trailing() {
-    let ( A  ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let (a ,): (E,); //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let ( A | B  ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let [ A | B  ]: [E; 1]; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let S { f: B  }; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let ( A | B  ): E; //~ ERROR unexpected token `||` in pattern
+    let ( A ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let (a,): (E,); //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let ( A | B ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let [ A | B ]: [E; 1]; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let S { f: B }; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let ( A | B ): E; //~ ERROR unexpected token `||` in pattern
     //~^ ERROR a trailing `|` is not allowed in an or-pattern
     match A {
-        A  => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
-        A  => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
-        A | B  => {} //~ ERROR unexpected token `||` in pattern
+        A => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
+        A => {} //~ ERROR a trailing `||` is not allowed in an or-pattern
+        A | B => {} //~ ERROR unexpected token `||` in pattern
         //~^ ERROR a trailing `|` is not allowed in an or-pattern
-        | A | B  => {}
+        | A | B => {}
         //~^ ERROR a trailing `|` is not allowed in an or-pattern
     }
 
     // These test trailing-vert in `let` bindings, but they also test that we don't emit a
     // duplicate suggestion that would confuse rustfix.
 
-    let a  : u8 = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let a  = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let a  ; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let a : u8 = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let a = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let a ; //~ ERROR a trailing `|` is not allowed in an or-pattern
 }
diff --git a/tests/ui/or-patterns/remove-leading-vert.rs b/tests/ui/or-patterns/remove-leading-vert.rs
index 1e1dbfbc6e6..1b4eb669fbb 100644
--- a/tests/ui/or-patterns/remove-leading-vert.rs
+++ b/tests/ui/or-patterns/remove-leading-vert.rs
@@ -32,7 +32,7 @@ fn trailing() {
     //~^ ERROR a trailing `|` is not allowed in an or-pattern
     match A {
         A | => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
-        A || => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
+        A || => {} //~ ERROR a trailing `||` is not allowed in an or-pattern
         A || B | => {} //~ ERROR unexpected token `||` in pattern
         //~^ ERROR a trailing `|` is not allowed in an or-pattern
         | A | B | => {}
diff --git a/tests/ui/or-patterns/remove-leading-vert.stderr b/tests/ui/or-patterns/remove-leading-vert.stderr
index 0323c64f042..29450153ba4 100644
--- a/tests/ui/or-patterns/remove-leading-vert.stderr
+++ b/tests/ui/or-patterns/remove-leading-vert.stderr
@@ -3,12 +3,6 @@ error: function parameters require top-level or-patterns in parentheses
    |
 LL |     fn fun1( | A: E) {}
    |              ^^^
-   |
-help: remove the `|`
-   |
-LL -     fn fun1( | A: E) {}
-LL +     fn fun1(  A: E) {}
-   |
 
 error: unexpected `||` before function parameter
   --> $DIR/remove-leading-vert.rs:12:14
@@ -78,12 +72,6 @@ LL |     let ( A | ): E;
    |           - ^
    |           |
    |           while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let ( A | ): E;
-LL +     let ( A  ): E;
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:27:12
@@ -92,12 +80,6 @@ LL |     let (a |,): (E,);
    |          - ^
    |          |
    |          while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let (a |,): (E,);
-LL +     let (a ,): (E,);
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:28:17
@@ -106,12 +88,6 @@ LL |     let ( A | B | ): E;
    |           -     ^
    |           |
    |           while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let ( A | B | ): E;
-LL +     let ( A | B  ): E;
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:29:17
@@ -120,12 +96,6 @@ LL |     let [ A | B | ]: [E; 1];
    |           -     ^
    |           |
    |           while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let [ A | B | ]: [E; 1];
-LL +     let [ A | B  ]: [E; 1];
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:30:18
@@ -134,12 +104,6 @@ LL |     let S { f: B | };
    |                - ^
    |                |
    |                while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let S { f: B | };
-LL +     let S { f: B  };
-   |
 
 error: unexpected token `||` in pattern
   --> $DIR/remove-leading-vert.rs:31:13
@@ -162,12 +126,6 @@ LL |     let ( A || B | ): E;
    |           -      ^
    |           |
    |           while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let ( A || B | ): E;
-LL +     let ( A || B  ): E;
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:34:11
@@ -176,14 +134,8 @@ LL |         A | => {}
    |         - ^
    |         |
    |         while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -         A | => {}
-LL +         A  => {}
-   |
 
-error: a trailing `|` is not allowed in an or-pattern
+error: a trailing `||` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:35:11
    |
 LL |         A || => {}
@@ -192,11 +144,6 @@ LL |         A || => {}
    |         while parsing this or-pattern starting here
    |
    = note: alternatives in or-patterns are separated with `|`, not `||`
-help: remove the `||`
-   |
-LL -         A || => {}
-LL +         A  => {}
-   |
 
 error: unexpected token `||` in pattern
   --> $DIR/remove-leading-vert.rs:36:11
@@ -219,12 +166,6 @@ LL |         A || B | => {}
    |         -      ^
    |         |
    |         while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -         A || B | => {}
-LL +         A || B  => {}
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:38:17
@@ -233,12 +174,6 @@ LL |         | A | B | => {}
    |         -       ^
    |         |
    |         while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -         | A | B | => {}
-LL +         | A | B  => {}
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:45:11
@@ -247,12 +182,6 @@ LL |     let a | : u8 = 0;
    |         - ^
    |         |
    |         while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let a | : u8 = 0;
-LL +     let a  : u8 = 0;
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:46:11
@@ -261,12 +190,6 @@ LL |     let a | = 0;
    |         - ^
    |         |
    |         while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let a | = 0;
-LL +     let a  = 0;
-   |
 
 error: a trailing `|` is not allowed in an or-pattern
   --> $DIR/remove-leading-vert.rs:47:11
@@ -275,12 +198,6 @@ LL |     let a | ;
    |         - ^
    |         |
    |         while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -     let a | ;
-LL +     let a  ;
-   |
 
 error: aborting due to 21 previous errors
 
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/ICE-130779-never-arm-no-oatherwise-block.stderr b/tests/ui/rfcs/rfc-0000-never_patterns/ICE-130779-never-arm-no-oatherwise-block.stderr
index 26731e29ffc..5f4a5f31e34 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/ICE-130779-never-arm-no-oatherwise-block.stderr
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/ICE-130779-never-arm-no-oatherwise-block.stderr
@@ -5,12 +5,6 @@ LL |         ! |
    |         - ^
    |         |
    |         while parsing this or-pattern starting here
-   |
-help: remove the `|`
-   |
-LL -         ! |
-LL +         !
-   |
 
 error: a never pattern is always unreachable
   --> $DIR/ICE-130779-never-arm-no-oatherwise-block.rs:10:20
diff --git a/tests/ui/span/borrowck-call-is-borrow-issue-12224.stderr b/tests/ui/span/borrowck-call-is-borrow-issue-12224.stderr
index 8081f7b3a8b..f7750884b4a 100644
--- a/tests/ui/span/borrowck-call-is-borrow-issue-12224.stderr
+++ b/tests/ui/span/borrowck-call-is-borrow-issue-12224.stderr
@@ -44,7 +44,7 @@ LL |
 LL |         foo(f);
    |             ^ move occurs because `f` has type `{closure@$DIR/borrowck-call-is-borrow-issue-12224.rs:52:17: 52:58}`, which does not implement the `Copy` trait
    |
-   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
 help: consider cloning the value if the performance cost is acceptable
    |
 LL |         foo(f.clone());
diff --git a/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr b/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr
index 132a31c8f7c..39c2fabf9eb 100644
--- a/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr
+++ b/tests/ui/suggestions/dont-suggest-ref/move-into-closure.stderr
@@ -12,7 +12,7 @@ LL |         let X(_t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -37,7 +37,7 @@ LL |         if let Either::One(_t) = e { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -62,7 +62,7 @@ LL |         while let Either::One(_t) = e { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -90,7 +90,7 @@ LL |             Either::One(_t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -118,7 +118,7 @@ LL |             Either::One(_t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -143,7 +143,7 @@ LL |         let X(mut _t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -168,7 +168,7 @@ LL |         if let Either::One(mut _t) = em { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -193,7 +193,7 @@ LL |         while let Either::One(mut _t) = em { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -221,7 +221,7 @@ LL |             Either::One(mut _t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -249,7 +249,7 @@ LL |             Either::One(mut _t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:13:18
    |
 LL | fn consume_fn<F: Fn()>(_f: F) { }
@@ -273,7 +273,7 @@ LL |         let X(_t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -298,7 +298,7 @@ LL |         if let Either::One(_t) = e { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -323,7 +323,7 @@ LL |         while let Either::One(_t) = e { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -351,7 +351,7 @@ LL |             Either::One(_t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -379,7 +379,7 @@ LL |             Either::One(_t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -404,7 +404,7 @@ LL |         let X(mut _t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -429,7 +429,7 @@ LL |         if let Either::One(mut _t) = em { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -454,7 +454,7 @@ LL |         while let Either::One(mut _t) = em { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -482,7 +482,7 @@ LL |             Either::One(mut _t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -510,7 +510,7 @@ LL |             Either::One(mut _t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:39:22
    |
 LL |     fn consume_fn<F: Fn()>(_f: F) { }
@@ -534,7 +534,7 @@ LL |         let X(_t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -559,7 +559,7 @@ LL |         if let Either::One(_t) = e { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -584,7 +584,7 @@ LL |         while let Either::One(_t) = e { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -612,7 +612,7 @@ LL |             Either::One(_t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -640,7 +640,7 @@ LL |             Either::One(_t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -665,7 +665,7 @@ LL |         let X(mut _t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -690,7 +690,7 @@ LL |         if let Either::One(mut _t) = em { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -715,7 +715,7 @@ LL |         while let Either::One(mut _t) = em { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -743,7 +743,7 @@ LL |             Either::One(mut _t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -771,7 +771,7 @@ LL |             Either::One(mut _t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:50:29
    |
 LL |     fn method_consume_fn<F: Fn()>(&self, _f: F) { }
@@ -795,7 +795,7 @@ LL |         let X(_t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -820,7 +820,7 @@ LL |         if let Either::One(_t) = e { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -845,7 +845,7 @@ LL |         while let Either::One(_t) = e { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -873,7 +873,7 @@ LL |             Either::One(_t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -901,7 +901,7 @@ LL |             Either::One(_t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -926,7 +926,7 @@ LL |         let X(mut _t) = x;
    |               data moved here
    |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -951,7 +951,7 @@ LL |         if let Either::One(mut _t) = em { }
    |                            data moved here
    |                            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -976,7 +976,7 @@ LL |         while let Either::One(mut _t) = em { }
    |                               data moved here
    |                               move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -1004,7 +1004,7 @@ LL |             Either::One(mut _t)
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -1032,7 +1032,7 @@ LL |             Either::One(mut _t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
@@ -1060,7 +1060,7 @@ LL |             Either::One(mut _t) => (),
    |                         data moved here
    |                         move occurs because `_t` has type `X`, which does not implement the `Copy` trait
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/move-into-closure.rs:25:21
    |
 LL | fn consume_fnmut<F: FnMut()>(_f: F) { }
diff --git a/tests/ui/suggestions/option-content-move2.stderr b/tests/ui/suggestions/option-content-move2.stderr
index c8aa6667b58..5bcbdd711ae 100644
--- a/tests/ui/suggestions/option-content-move2.stderr
+++ b/tests/ui/suggestions/option-content-move2.stderr
@@ -14,7 +14,7 @@ LL |
 LL |             var = Some(NotCopyable);
    |             --- variable moved due to use in closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/option-content-move2.rs:5:12
    |
 LL | fn func<F: FnMut() -> H, H: FnMut()>(_: F) {}
@@ -44,7 +44,7 @@ LL |
 LL |             var = Some(NotCopyableButCloneable);
    |             --- variable moved due to use in closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/option-content-move2.rs:5:12
    |
 LL | fn func<F: FnMut() -> H, H: FnMut()>(_: F) {}
diff --git a/tests/ui/suggestions/option-content-move3.stderr b/tests/ui/suggestions/option-content-move3.stderr
index 2c9a86c036b..f78d3cf6786 100644
--- a/tests/ui/suggestions/option-content-move3.stderr
+++ b/tests/ui/suggestions/option-content-move3.stderr
@@ -9,7 +9,7 @@ LL |         move || {
 LL |             let x = var;
    |                     ^^^ move occurs because `var` has type `NotCopyable`, which does not implement the `Copy` trait
    |
-   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
 note: if `NotCopyable` implemented `Clone`, you could clone the value
   --> $DIR/option-content-move3.rs:2:1
    |
@@ -38,7 +38,7 @@ LL |         move || {
 LL |             let x = var;
    |                     --- variable moved due to use in closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/option-content-move3.rs:6:12
    |
 LL | fn func<F: FnMut() -> H, H: FnMut()>(_: F) {}
@@ -63,7 +63,7 @@ LL |         move || {
 LL |             let x = var;
    |                     ^^^ move occurs because `var` has type `NotCopyableButCloneable`, which does not implement the `Copy` trait
    |
-   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+   = help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
 help: consider borrowing here
    |
 LL |             let x = &var;
@@ -84,7 +84,7 @@ LL |         move || {
 LL |             let x = var;
    |                     --- variable moved due to use in closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/option-content-move3.rs:6:12
    |
 LL | fn func<F: FnMut() -> H, H: FnMut()>(_: F) {}
diff --git a/tests/ui/unboxed-closures/unboxed-closure-illegal-move.stderr b/tests/ui/unboxed-closures/unboxed-closure-illegal-move.stderr
index 9d87402a15b..266da54941d 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-illegal-move.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-illegal-move.stderr
@@ -10,7 +10,7 @@ LL |         let f = to_fn(|| drop(x));
    |                       |
    |                       captured by this `Fn` closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/unboxed-closure-illegal-move.rs:7:33
    |
 LL | fn to_fn<A:std::marker::Tuple,F:Fn<A>>(f: F) -> F { f }
@@ -32,7 +32,7 @@ LL |         let f = to_fn_mut(|| drop(x));
    |                           |
    |                           captured by this `FnMut` closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/unboxed-closure-illegal-move.rs:8:37
    |
 LL | fn to_fn_mut<A:std::marker::Tuple,F:FnMut<A>>(f: F) -> F { f }
@@ -54,7 +54,7 @@ LL |         let f = to_fn(move || drop(x));
    |                       |
    |                       captured by this `Fn` closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/unboxed-closure-illegal-move.rs:7:33
    |
 LL | fn to_fn<A:std::marker::Tuple,F:Fn<A>>(f: F) -> F { f }
@@ -72,7 +72,7 @@ LL |         let f = to_fn_mut(move || drop(x));
    |                           |
    |                           captured by this `FnMut` closure
    |
-help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but an `FnOnce` consume them only once
+help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
   --> $DIR/unboxed-closure-illegal-move.rs:8:37
    |
 LL | fn to_fn_mut<A:std::marker::Tuple,F:FnMut<A>>(f: F) -> F { f }