Commit 84c2c47fae82e913286a2306d8947252ae3a42f7 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-01-17 20:45:55-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-01-17 20:45:55-07:00
log	84c2c47fae82e913286a2306d8947252ae3a42f7
tree	a57dc1f9a211f3852496988ae1e09a222e9d6f29
parent	2600978a9ddc295c347fd6ffe7c6ba20931b956e

Sema: implement else capture value

The ZIR instructions `switch_capture_else` and `switch_capture_ref` are
removed because they are not needed. Instead, the prong index is set to
max int for the special prong.

Else prong with error sets is not handled yet.

Adds a new behavior test because there was not a prior on to cover only
the capture value of else on a switch.

8 files changed, 71 insertions(+), 61 deletions(-)

src
test
- behavior.zig
- behavior

src/AstGen.zig+9-8

 @@ -2198,8 +2198,6 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: Ast.Node.Index) Inner
             .switch_capture_ref,
             .switch_capture_multi,
             .switch_capture_multi_ref,
-            .switch_capture_else,
-            .switch_capture_else_ref,
             .struct_init_empty,
             .struct_init,
             .struct_init_ref,
 @@ -5758,16 +5756,19 @@ fn switchExpr(
             }
             if (case_node == special_node) {
                 const capture_tag: Zir.Inst.Tag = if (is_ptr)
-                    .switch_capture_else_ref
+                    .switch_capture_ref
                 else
-                    .switch_capture_else;
+                    .switch_capture;
                 capture_inst = @intCast(Zir.Inst.Index, astgen.instructions.len);
                 try astgen.instructions.append(gpa, .{
                     .tag = capture_tag,
-                    .data = .{ .switch_capture = .{
+                    .data = .{
-                        .switch_inst = switch_block,
+                        .switch_capture = .{
-                        .prong_index = undefined,
+                            .switch_inst = switch_block,
-                    } },
+                            // Max int communicates that this is the else/underscore prong.
+                            .prong_index = std.math.maxInt(u32),
+                        },
+                    },
                 });
             } else {
                 const is_multi_case_bits: u2 = @boolToInt(is_multi_case);

src/Sema.zig+21-22

 @@ -669,8 +669,6 @@ fn analyzeBodyInner(
             .switch_capture_ref           => try sema.zirSwitchCapture(block, inst, false, true),
             .switch_capture_multi         => try sema.zirSwitchCapture(block, inst, true, false),
             .switch_capture_multi_ref     => try sema.zirSwitchCapture(block, inst, true, true),
-            .switch_capture_else          => try sema.zirSwitchCaptureElse(block, inst, false),
-            .switch_capture_else_ref      => try sema.zirSwitchCaptureElse(block, inst, true),
             .type_info                    => try sema.zirTypeInfo(block, inst),
             .size_of                      => try sema.zirSizeOf(block, inst),
             .bit_size_of                  => try sema.zirBitSizeOf(block, inst),
 @@ -6071,6 +6069,27 @@ fn zirSwitchCapture(
     const operand_ptr_ty = sema.typeOf(operand_ptr);
     const operand_ty = if (operand_is_ref) operand_ptr_ty.childType() else operand_ptr_ty;
+    if (capture_info.prong_index == std.math.maxInt(@TypeOf(capture_info.prong_index))) {
+        // It is the else/`_` prong.
+        switch (operand_ty.zigTypeTag()) {
+            .ErrorSet => {
+                return sema.fail(block, operand_src, "TODO implement Sema for zirSwitchCaptureElse for error sets", .{});
+            },
+            else => {},
+        }
+        if (is_ref) {
+            assert(operand_is_ref);
+            return operand_ptr;
+        }
+        const operand = if (operand_is_ref)
+            try sema.analyzeLoad(block, operand_src, operand_ptr, operand_src)
+        else
+            operand_ptr;
+        return operand;
+    }
     if (is_multi) {
         return sema.fail(block, switch_src, "TODO implement Sema for switch capture multi", .{});
     }
 @@ -6137,26 +6156,6 @@ fn zirSwitchCapture(
     }
 }
-fn zirSwitchCaptureElse(
-    sema: *Sema,
-    block: *Block,
-    inst: Zir.Inst.Index,
-    is_ref: bool,
-) CompileError!Air.Inst.Ref {
-    const tracy = trace(@src());
-    defer tracy.end();
-    const zir_datas = sema.code.instructions.items(.data);
-    const capture_info = zir_datas[inst].switch_capture;
-    const switch_info = zir_datas[capture_info.switch_inst].pl_node;
-    const switch_extra = sema.code.extraData(Zir.Inst.SwitchBlock, switch_info.payload_index).data;
-    const src = switch_info.src();
-    const operand_is_ref = switch_extra.bits.is_ref;
-    assert(!is_ref or operand_is_ref);
-    return sema.fail(block, src, "TODO implement Sema for zirSwitchCaptureElse", .{});
-}
 fn zirSwitchCond(
     sema: *Sema,
     block: *Block,

src/Zir.zig+9-11

 @@ -625,10 +625,14 @@ pub const Inst = struct {
         switch_cond_ref,
         /// Produces the capture value for a switch prong.
         /// Uses the `switch_capture` field.
+        /// If the `prong_index` field is max int, it means this is the capture
+        /// for the else/`_` prong.
         switch_capture,
         /// Produces the capture value for a switch prong.
         /// Result is a pointer to the value.
         /// Uses the `switch_capture` field.
+        /// If the `prong_index` field is max int, it means this is the capture
+        /// for the else/`_` prong.
         switch_capture_ref,
         /// Produces the capture value for a switch prong.
         /// The prong is one of the multi cases.
 @@ -639,13 +643,6 @@ pub const Inst = struct {
         /// Result is a pointer to the value.
         /// Uses the `switch_capture` field.
         switch_capture_multi_ref,
-        /// Produces the capture value for the else/'_' switch prong.
-        /// Uses the `switch_capture` field.
-        switch_capture_else,
-        /// Produces the capture value for the else/'_' switch prong.
-        /// Result is a pointer to the value.
-        /// Uses the `switch_capture` field.
-        switch_capture_else_ref,
         /// Given a set of `field_ptr` instructions, assumes they are all part of a struct
         /// initialization expression, and emits compile errors for duplicate fields
         /// as well as missing fields, if applicable.
 @@ -1082,8 +1079,6 @@ pub const Inst = struct {
                 .switch_capture_ref,
                 .switch_capture_multi,
                 .switch_capture_multi_ref,
-                .switch_capture_else,
-                .switch_capture_else_ref,
                 .switch_block,
                 .switch_cond,
                 .switch_cond_ref,
 @@ -1340,8 +1335,6 @@ pub const Inst = struct {
                 .switch_capture_ref = .switch_capture,
                 .switch_capture_multi = .switch_capture,
                 .switch_capture_multi_ref = .switch_capture,
-                .switch_capture_else = .switch_capture,
-                .switch_capture_else_ref = .switch_capture,
                 .validate_struct_init = .pl_node,
                 .validate_struct_init_comptime = .pl_node,
                 .validate_array_init = .pl_node,
 @@ -1469,6 +1462,11 @@ pub const Inst = struct {
                 .extended = .extended,
             });
         };
+        // Uncomment to view how many tag slots are available.
+        //comptime {
+        //    @compileLog("ZIR tags left: ", 256 - @typeInfo(Tag).Enum.fields.len);
+        //}
     };
     /// Rarer instructions are here; ones that do not fit in the 8-bit `Tag` enum.

src/print_zir.zig-2

...	@@ -425,8 +425,6 @@ const Writer = struct {	...	@@ -425,8 +425,6 @@ const Writer = struct {
425	.switch_capture_ref,	425	.switch_capture_ref,
426	.switch_capture_multi,	426	.switch_capture_multi,
427	.switch_capture_multi_ref,	427	.switch_capture_multi_ref,
428	.switch_capture_else,
429	.switch_capture_else_ref,
430	=> try self.writeSwitchCapture(stream, inst),	428	=> try self.writeSwitchCapture(stream, inst),
431		429
432	.dbg_stmt => try self.writeDbgStmt(stream, inst),	430	.dbg_stmt => try self.writeDbgStmt(stream, inst),

test/behavior.zig-1

...	@@ -203,7 +203,6 @@ test {	...	@@ -203,7 +203,6 @@ test {
203	if (builtin.target.cpu.arch == .wasm32) {	203	if (builtin.target.cpu.arch == .wasm32) {
204	_ = @import("behavior/wasm.zig");	204	_ = @import("behavior/wasm.zig");
205	}	205	}
206	_ = @import("behavior/while_stage1.zig");
207	_ = @import("behavior/translate_c_macros_stage1.zig");	206	_ = @import("behavior/translate_c_macros_stage1.zig");
208	}	207	}
209	}	208	}

test/behavior/switch.zig+15

...	@@ -359,6 +359,21 @@ fn return_a_number() anyerror!i32 {	...	@@ -359,6 +359,21 @@ fn return_a_number() anyerror!i32 {
359	return 1;	359	return 1;
360	}	360	}
361		361
		362	test "switch on integer with else capturing expr" {
		363	const S = struct {
		364	fn doTheTest() !void {
		365	var x: i32 = 5;
		366	switch (x + 10) {
		367	14 => @panic("fail"),
		368	16 => @panic("fail"),
		369	else => \|e\| try expect(e == 15),
		370	}
		371	}
		372	};
		373	try S.doTheTest();
		374	comptime try S.doTheTest();
		375	}
		376
362	test "else prong of switch on error set excludes other cases" {	377	test "else prong of switch on error set excludes other cases" {
363	if (@import("builtin").zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO	378	if (@import("builtin").zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
364		379

test/behavior/while.zig+17

...	@@ -266,3 +266,20 @@ test "while optional 2 break statements and an else" {	...	@@ -266,3 +266,20 @@ test "while optional 2 break statements and an else" {
266	try S.entry(true, false);	266	try S.entry(true, false);
267	comptime try S.entry(true, false);	267	comptime try S.entry(true, false);
268	}	268	}
		269
		270	test "while error 2 break statements and an else" {
		271	if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest; // TODO
		272
		273	const S = struct {
		274	fn entry(opt_t: anyerror!bool, f: bool) !void {
		275	var ok = false;
		276	ok = while (opt_t) \|t\| {
		277	if (f) break false;
		278	if (t) break true;
		279	} else \|_\| false;
		280	try expect(ok);
		281	}
		282	};
		283	try S.entry(true, false);
		284	comptime try S.entry(true, false);
		285	}

test/behavior/while_stage1.zig deleted-17

...	@@ -1,17 +0,0 @@
1	const std = @import("std");
2	const expect = std.testing.expect;
3
4	test "while error 2 break statements and an else" {
5	const S = struct {
6	fn entry(opt_t: anyerror!bool, f: bool) !void {
7	var ok = false;
8	ok = while (opt_t) \|t\| {
9	if (f) break false;
10	if (t) break true;
11	} else \|_\| false;
12	try expect(ok);
13	}
14	};
15	try S.entry(true, false);
16	comptime try S.entry(true, false);
17	}