Commit ef93a36cd5

@@ -4628,6 +4628,7 @@ test "while null capture" {
     }
     try expect(sum1 == 3);
 
+    // null capture with an else block
     var sum2: u32 = 0;
     numbers_left = 3;
     while (eventuallyNullSequence()) |value| {
@@ -4636,6 +4637,7 @@ test "while null capture" {
         try expect(sum2 == 3);
     }
 
+    // null capture with a continue expression
     var i: u32 = 0;
     var sum3: u32 = 0;
     numbers_left = 3;
@@ -4923,87 +4925,92 @@ test "if boolean" {
     }
 }
 
-test "if optional" {
-    // If expressions test for null.
+test "if error union" {
+    // If expressions test for errors.
+    // Note the |err| capture on the else.
 
-    const a: ?u32 = 0;
+    const a: anyerror!u32 = 0;
     if (a) |value| {
         try expect(value == 0);
-    } else {
+    } else |err| {
+        _ = err;
         unreachable;
     }
 
-    const b: ?u32 = null;
-    if (b) |_| {
+    const b: anyerror!u32 = error.BadValue;
+    if (b) |value| {
+        _ = value;
         unreachable;
-    } else {
-        try expect(true);
+    } else |err| {
+        try expect(err == error.BadValue);
     }
 
-    // The else is not required.
+    // The else and |err| capture is strictly required.
     if (a) |value| {
         try expect(value == 0);
-    }
+    } else |_| {}
 
-    // To test against null only, use the binary equality operator.
-    if (b == null) {
-        try expect(true);
+    // To check only the error value, use an empty block expression.
+    if (b) |_| {} else |err| {
+        try expect(err == error.BadValue);
     }
 
     // Access the value by reference using a pointer capture.
-    var c: ?u32 = 3;
+    var c: anyerror!u32 = 3;
     if (c) |*value| {
-        value.* = 2;
+        value.* = 9;
+    } else |_| {
+        unreachable;
     }
 
     if (c) |value| {
-        try expect(value == 2);
-    } else {
+        try expect(value == 9);
+    } else |_| {
         unreachable;
     }
 }
+      {#code_end#}
+      {#header_open|if with Optionals#}
 
-test "if error union" {
-    // If expressions test for errors.
-    // Note the |err| capture on the else.
+      {#code_begin|test|test_if_optionals#}
+const expect = @import("std").testing.expect;
 
-    const a: anyerror!u32 = 0;
+test "if optional" {
+    // If expressions test for null.
+
+    const a: ?u32 = 0;
     if (a) |value| {
         try expect(value == 0);
-    } else |err| {
-        _ = err;
+    } else {
         unreachable;
     }
 
-    const b: anyerror!u32 = error.BadValue;
-    if (b) |value| {
-        _ = value;
+    const b: ?u32 = null;
+    if (b) |_| {
         unreachable;
-    } else |err| {
-        try expect(err == error.BadValue);
+    } else {
+        try expect(true);
     }
 
-    // The else and |err| capture is strictly required.
+    // The else is not required.
     if (a) |value| {
         try expect(value == 0);
-    } else |_| {}
+    }
 
-    // To check only the error value, use an empty block expression.
-    if (b) |_| {} else |err| {
-        try expect(err == error.BadValue);
+    // To test against null only, use the binary equality operator.
+    if (b == null) {
+        try expect(true);
     }
 
     // Access the value by reference using a pointer capture.
-    var c: anyerror!u32 = 3;
+    var c: ?u32 = 3;
     if (c) |*value| {
-        value.* = 9;
-    } else |_| {
-        unreachable;
+        value.* = 2;
     }
 
     if (c) |value| {
-        try expect(value == 9);
-    } else |_| {
+        try expect(value == 2);
+    } else {
         unreachable;
     }
 }
@@ -5052,6 +5059,7 @@ test "if error union with optional" {
     }
 }
       {#code_end#}
+      {#header_close#}
       {#see_also|Optionals|Errors#}
       {#header_close#}
       {#header_open|defer#}
@@ -6338,7 +6346,7 @@ test "optional pointers" {
       {#code_end#}
       {#header_close#}
 
-      {#see_also|while with Optionals|if#}
+      {#see_also|while with Optionals|if with Optionals#}
       {#header_close#}
       {#header_open|Casting#}
       <p>