Use functions returning ! in tests

Author: jackh726

src/expressions/block-expr.md

@@ -66,43 +66,49 @@ assert_eq!(5, five);
 r[expr.block.type.diverging]
 A block is itself considered to be [diverging](../divergence.md) if all reachable control flow paths contain a [diverging expression](../divergence.md#r-divergence.diverging-expressions), unless that expression is a place expression that is not read from.
 
-```rust
-# #![ feature(never_type) ]
+```rust,no_run
 # fn make<T>() -> T { loop {} }
-let no_control_flow: ! = {
+fn no_control_flow() -> ! {
     // There are no conditional statements, so this entire block is diverging.
     loop {}
-};
+}
 
-let control_flow_diverging: ! = {
+fn control_flow_diverging() -> ! {
     // All paths are diverging, so this entire block is diverging.
     if true {
         loop {}
     } else {
         loop {}
     }
-};
+}
 
-let control_flow_not_diverging: () = {
+fn control_flow_not_diverging() -> () {
     // Some paths are not diverging, so this entire block is not diverging.
     if true {
         ()
     } else {
         loop {}
     }
-};
+}
 
 struct Foo {
     x: !,
 }
 
-let foo = Foo { x: make() };
-let diverging_place_not_read: () = {
+fn diverging_place_read() -> () {
+    let foo = Foo { x: make() };
+    let _: ! = {
+        // A read of a place expression produces a diverging block
+        let _x = foo.x;
+    };
+}
+fn diverging_place_not_read() -> () {
+    let foo = Foo { x: make() };
     let _: () = {
         // Asssignment to `_` means the place is not read
         let _ = foo.x;
     };
-};
+}
 ```
 
 r[expr.block.value]

src/expressions/if-expr.md

@@ -76,20 +76,24 @@ assert_eq!(y, "Bigger");
 r[expr.if.diverging]
 An `if` expression diverges if either the condition expression diverges or if all arms diverge.
 
-```rust
-# #![ feature(never_type) ]
-// Diverges because the condition expression diverges
-let x: ! = if { loop {}; true } {
-    ()
-} else {
-    ()
-};
+```rust,no_run
+fn diverging_condition() -> ! {
+    // Diverges because the condition expression diverges
+    if { loop {}; true } {
+        ()
+    } else {
+        ()
+    }
+}
 
-let x: ! = if true {
-    loop {}
-} else {
-    loop {}
-};
+fn diverging_arms() -> ! {
+    // Diverges because all arms diverge
+    if true {
+        loop {}
+    } else {
+        loop {}
+    }
+}
 ```
 
 r[expr.if.let]