Update examples for never type stabilization

Some of these examples can be simplified with using the never type.

Author: ehuss

src/attributes/diagnostics.md

@@ -401,11 +401,10 @@ As an exception to [attributes.diagnostics.must_use.type], the lint does not fir
 ```rust
 #![deny(unused_must_use)]
 # use core::ops::ControlFlow;
-enum Empty {}
-fn f1() -> Result<(), Empty> { Ok(()) }
-f1(); // OK: `Empty` is uninhabited.
-fn f2() -> ControlFlow<Empty, ()> { ControlFlow::Continue(()) }
-f2(); // OK: `Empty` is uninhabited.
+fn f1() -> Result<(), !> { Ok(()) }
+f1(); // OK: `!` is uninhabited.
+fn f2() -> ControlFlow<!, ()> { ControlFlow::Continue(()) }
+f2(); // OK: `!` is uninhabited.
 ```
 
 r[attributes.diagnostics.must_use.fn]

src/expressions/block-expr.md

@@ -91,7 +91,6 @@ r[expr.block.diverging]
 A block is considered to be [diverging][divergence] if all reachable control flow paths contain a diverging expression, unless that expression is a [place expression] that is not read from.
 
 ```rust,no_run
-# #![ feature(never_type) ]
 fn no_control_flow() -> ! {
     // There are no conditional statements, so this entire function body is diverging.
     loop {}
@@ -115,10 +114,6 @@ fn control_flow_not_diverging() -> () {
     }
 }
 
-// Note: This makes use of the unstable never type which is only available on
-// Rust's nightly channel. This is done for illustration purposes. It is
-// possible to encounter this scenario in stable Rust, but requires a more
-// convoluted example.
 struct Foo {
     x: !,
 }
@@ -133,7 +128,6 @@ fn diverging_place_read() -> ! {
 ```
 
 ```rust,compile_fail,E0308
-# #![ feature(never_type) ]
 # fn make<T>() -> T { loop {} }
 # struct Foo {
 #     x: !,

src/expressions/match-expr.md

@@ -119,11 +119,7 @@ If there are no match arms, then the `match` expression is [diverging] and the t
 
 > [!EXAMPLE]
 > ```rust
-> # fn make<T>() -> T { loop {} }
-> enum Empty {}
->
-> fn diverging_match_no_arms() -> ! {
->     let e: Empty = make();
+> fn diverging_match_no_arms(e: !) -> ! {
 >     match e {}
 > }
 > ```

src/types/closure.md

@@ -340,8 +340,7 @@ r[type.closure.capture.precision.discriminants.uninhabited-variants]
 Even if all variants but the one being matched against are uninhabited, making the pattern [irrefutable][patterns.refutable], the discriminant is still read if it otherwise would be.
 
 ```rust,compile_fail,E0502
-enum Empty {}
-let mut x = Ok::<_, Empty>(42);
+let mut x = Ok::<_, !>(42);
 let c = || {
     let Ok(_) = x; // Captures `x` by `ImmBorrow`.
 };