Commit b936fe0a5855872814c9f70f958363f64896217b | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-03-09 15:07:00-05:00
committer	GitHub <noreply@github.com> 2022-03-09 15:07:00-05:00
log	b936fe0a5855872814c9f70f958363f64896217b
tree	e5ac6ea062d051f5b062d3d11643d17e6dfd58ff
parent	0f0d27ce2427bff9d48d14b829e29a2003ba0e9c
parent	01b454f8515312531ff0c70985203f9aecb022db
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11101 from Vexu/stage2

Sema: handle noreturn result in condbr_inline

6 files changed, 88 insertions(+), 38 deletions(-)

src
test
- behavior.zig
- behavior
  - basic.zig
  - bugs
    11100.zig

src/AstGen.zig+4

...	@@ -1991,6 +1991,9 @@ fn labeledBlockExpr(	...	@@ -1991,6 +1991,9 @@ fn labeledBlockExpr(
1991	defer block_scope.labeled_breaks.deinit(astgen.gpa);	1991	defer block_scope.labeled_breaks.deinit(astgen.gpa);
1992		1992
1993	try blockExprStmts(&block_scope, &block_scope.base, statements);	1993	try blockExprStmts(&block_scope, &block_scope.base, statements);
		1994	if (!block_scope.endsWithNoReturn()) {
		1995	_ = try block_scope.addBreak(.break_inline, block_inst, .void_value);
		1996	}
1994		1997
1995	if (!block_scope.label.?.used) {	1998	if (!block_scope.label.?.used) {
1996	try astgen.appendErrorTok(label_token, "unused block label", .{});	1999	try astgen.appendErrorTok(label_token, "unused block label", .{});
...	@@ -7646,6 +7649,7 @@ fn cImport(	...	@@ -7646,6 +7649,7 @@ fn cImport(
7646		7649
7647	const block_inst = try gz.makeBlockInst(.c_import, node);	7650	const block_inst = try gz.makeBlockInst(.c_import, node);
7648	const block_result = try expr(&block_scope, &block_scope.base, .none, body_node);	7651	const block_result = try expr(&block_scope, &block_scope.base, .none, body_node);
		7652	_ = try gz.addUnNode(.ensure_result_used, block_result, node);
7649	if (!gz.refIsNoReturn(block_result)) {	7653	if (!gz.refIsNoReturn(block_result)) {
7650	_ = try block_scope.addBreak(.break_inline, block_inst, .void_value);	7654	_ = try block_scope.addBreak(.break_inline, block_inst, .void_value);
7651	}	7655	}

src/Module.zig+2-4

 @@ -3739,9 +3739,8 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
     const inst_data = zir_datas[zir_block_index].pl_node;
     const extra = zir.extraData(Zir.Inst.Block, inst_data.payload_index);
     const body = zir.extra[extra.end..][0..extra.data.body_len];
-    const break_index = try sema.analyzeBody(&block_scope, body);
+    const result_ref = (try sema.analyzeBodyBreak(&block_scope, body)).?.operand;
     try wip_captures.finalize();
-    const result_ref = zir_datas[break_index].@"break".operand;
     const src: LazySrcLoc = .{ .node_offset = 0 };
     const decl_tv = try sema.resolveInstValue(&block_scope, src, result_ref);
     const align_val = blk: {
 @@ -4681,12 +4680,11 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn, arena: Allocator) Sem
     func.state = .in_progress;
     log.debug("set {s} to in_progress", .{decl.name});
-    _ = sema.analyzeBody(&inner_block, fn_info.body) catch |err| switch (err) {
+    sema.analyzeBody(&inner_block, fn_info.body) catch |err| switch (err) {
         // TODO make these unreachable instead of @panic
         error.NeededSourceLocation => @panic("zig compiler bug: NeededSourceLocation"),
         error.GenericPoison => @panic("zig compiler bug: GenericPoison"),
         error.ComptimeReturn => @panic("zig compiler bug: ComptimeReturn"),
-        error.ComptimeBreak => @panic("zig compiler bug: ComptimeBreak"),
         else => |e| return e,
     };

src/Sema.zig+63-34

 @@ -520,14 +520,14 @@ fn resolveBody(
     /// use to return from the body.
     body_inst: Zir.Inst.Index,
 ) CompileError!Air.Inst.Ref {
-    const break_inst = try sema.analyzeBody(block, body);
+    const break_data = (try sema.analyzeBodyBreak(block, body)) orelse
-    const break_data = sema.code.instructions.items(.data)[break_inst].@"break";
+        return Air.Inst.Ref.unreachable_value;
     // For comptime control flow, we need to detect when `analyzeBody` reports
     // that we need to break from an outer block. In such case we
     // use Zig's error mechanism to send control flow up the stack until
     // we find the corresponding block to this break.
     if (block.is_comptime and break_data.block_inst != body_inst) {
-        sema.comptime_break_inst = break_inst;
+        sema.comptime_break_inst = break_data.inst;
         return error.ComptimeBreak;
     }
     return sema.resolveInst(break_data.operand);
 @@ -537,11 +537,37 @@ pub fn analyzeBody(
     sema: *Sema,
     block: *Block,
     body: []const Zir.Inst.Index,
-) CompileError!Zir.Inst.Index {
+) !void {
-    return sema.analyzeBodyInner(block, body) catch |err| switch (err) {
+    _ = sema.analyzeBodyInner(block, body) catch |err| switch (err) {
+        error.ComptimeBreak => unreachable, // unexpected comptime control flow
+        else => |e| return e,
+    };
+}
+const BreakData = struct {
+    block_inst: Zir.Inst.Index,
+    operand: Air.Inst.Ref,
+    inst: Air.Inst.Index,
+};
+pub fn analyzeBodyBreak(
+    sema: *Sema,
+    block: *Block,
+    body: []const Zir.Inst.Index,
+) CompileError!?BreakData {
+    const break_inst = sema.analyzeBodyInner(block, body) catch |err| switch (err) {
         error.ComptimeBreak => sema.comptime_break_inst,
         else => |e| return e,
     };
+    if (block.instructions.items.len != 0 and
+        sema.typeOf(Air.indexToRef(block.instructions.items[block.instructions.items.len - 1])).isNoReturn())
+        return null;
+    const break_data = sema.code.instructions.items(.data)[break_inst].@"break";
+    return BreakData{
+        .block_inst = break_data.block_inst,
+        .operand = break_data.operand,
+        .inst = break_inst,
+    };
 }
 /// ZIR instructions which are always `noreturn` return this. This matches the
 @@ -1045,12 +1071,12 @@ fn analyzeBodyInner(
                 const inst_data = datas[inst].pl_node;
                 const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index);
                 const inline_body = sema.code.extra[extra.end..][0..extra.data.body_len];
-                const break_inst = try sema.analyzeBody(block, inline_body);
+                const break_data = (try sema.analyzeBodyBreak(block, inline_body)) orelse
-                const break_data = datas[break_inst].@"break";
+                    break always_noreturn;
                 if (inst == break_data.block_inst) {
                     break :blk sema.resolveInst(break_data.operand);
                 } else {
-                    break break_inst;
+                    break break_data.inst;
                 }
             },
             .block => blk: {
 @@ -1068,12 +1094,12 @@ fn analyzeBodyInner(
                     block.params.deinit(sema.gpa);
                     block.params = prev_params;
                 }
-                const break_inst = try sema.analyzeBody(block, inline_body);
+                const break_data = (try sema.analyzeBodyBreak(block, inline_body)) orelse
-                const break_data = datas[break_inst].@"break";
+                    break always_noreturn;
                 if (inst == break_data.block_inst) {
                     break :blk sema.resolveInst(break_data.operand);
                 } else {
-                    break break_inst;
+                    break break_data.inst;
                 }
             },
             .block_inline => blk: {
 @@ -1090,12 +1116,12 @@ fn analyzeBodyInner(
                     block.params.deinit(sema.gpa);
                     block.params = prev_params;
                 }
-                const break_inst = try sema.analyzeBody(block, inline_body);
+                const break_data = (try sema.analyzeBodyBreak(block, inline_body)) orelse
-                const break_data = datas[break_inst].@"break";
+                    break always_noreturn;
                 if (inst == break_data.block_inst) {
                     break :blk sema.resolveInst(break_data.operand);
                 } else {
-                    break break_inst;
+                    break break_data.inst;
                 }
             },
             .condbr => blk: {
 @@ -1108,12 +1134,12 @@ fn analyzeBodyInner(
                 const else_body = sema.code.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
                 const cond = try sema.resolveInstConst(block, cond_src, extra.data.condition);
                 const inline_body = if (cond.val.toBool()) then_body else else_body;
-                const break_inst = try sema.analyzeBody(block, inline_body);
+                const break_data = (try sema.analyzeBodyBreak(block, inline_body)) orelse
-                const break_data = datas[break_inst].@"break";
+                    break always_noreturn;
                 if (inst == break_data.block_inst) {
                     break :blk sema.resolveInst(break_data.operand);
                 } else {
-                    break break_inst;
+                    break break_data.inst;
                 }
             },
             .condbr_inline => blk: {
 @@ -1124,12 +1150,12 @@ fn analyzeBodyInner(
                 const else_body = sema.code.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
                 const cond = try sema.resolveInstConst(block, cond_src, extra.data.condition);
                 const inline_body = if (cond.val.toBool()) then_body else else_body;
-                const break_inst = try sema.analyzeBody(block, inline_body);
+                const break_data = (try sema.analyzeBodyBreak(block, inline_body)) orelse
-                const break_data = datas[break_inst].@"break";
+                    break always_noreturn;
                 if (inst == break_data.block_inst) {
                     break :blk sema.resolveInst(break_data.operand);
                 } else {
-                    break break_inst;
+                    break break_data.inst;
                 }
             },
         };
 @@ -1915,7 +1941,7 @@ fn zirEnumDecl(
         defer assert(enum_block.instructions.items.len == 0); // should all be comptime instructions
         if (body.len != 0) {
-            _ = try sema.analyzeBody(&enum_block, body);
+            try sema.analyzeBody(&enum_block, body);
         }
         try wip_captures.finalize();
 @@ -3639,7 +3665,7 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError
     var loop_block = child_block.makeSubBlock();
     defer loop_block.instructions.deinit(gpa);
-    _ = try sema.analyzeBody(&loop_block, body);
+    try sema.analyzeBody(&loop_block, body);
     try child_block.instructions.append(gpa, loop_inst);
 @@ -3681,7 +3707,8 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
     };
     defer child_block.instructions.deinit(sema.gpa);
-    _ = try sema.analyzeBody(&child_block, body);
+    // Ignore the result, all the relevant operations have written to c_import_buf already.
+    _ = try sema.analyzeBodyBreak(&child_block, body);
     const c_import_res = sema.mod.comp.cImport(c_import_buf.items) catch |err|
         return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
 @@ -4658,9 +4685,8 @@ fn analyzeCall(
             }
             const result = result: {
-                _ = sema.analyzeBody(&child_block, fn_info.body) catch |err| switch (err) {
+                sema.analyzeBody(&child_block, fn_info.body) catch |err| switch (err) {
                     error.ComptimeReturn => break :result inlining.comptime_result,
-                    error.ComptimeBreak => unreachable, // Can't break through a fn call.
                     error.AnalysisFail => {
                         const err_msg = inlining.err orelse return err;
                         try sema.errNote(block, call_src, err_msg, "called from here", .{});
 @@ -7313,7 +7339,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         const item = sema.resolveInst(item_ref);
         // `item` is already guaranteed to be constant known.
-        _ = try sema.analyzeBody(&case_block, body);
+        try sema.analyzeBody(&case_block, body);
         try wip_captures.finalize();
 @@ -7356,7 +7382,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
             const body = sema.code.extra[extra_index..][0..body_len];
             extra_index += body_len;
-            _ = try sema.analyzeBody(&case_block, body);
+            try sema.analyzeBody(&case_block, body);
             try cases_extra.ensureUnusedCapacity(gpa, 2 + items.len +
                 case_block.instructions.items.len);
 @@ -7431,7 +7457,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
             const body = sema.code.extra[extra_index..][0..body_len];
             extra_index += body_len;
-            _ = try sema.analyzeBody(&case_block, body);
+            try sema.analyzeBody(&case_block, body);
             try wip_captures.finalize();
 @@ -7468,7 +7494,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         case_block.wip_capture_scope = wip_captures.scope;
         if (special.body.len != 0) {
-            _ = try sema.analyzeBody(&case_block, special.body);
+            try sema.analyzeBody(&case_block, special.body);
         } else {
             // We still need a terminator in this block, but we have proven
             // that it is unreachable.
 @@ -10990,7 +11016,8 @@ fn zirTypeofPeer(
         .is_typeof = true,
     };
     defer child_block.instructions.deinit(sema.gpa);
-    _ = try sema.analyzeBody(&child_block, body);
+    // Ignore the result, we only care about the instructions in `args`.
+    _ = try sema.analyzeBodyBreak(&child_block, body);
     const args = sema.code.refSlice(extra.end, extended.small);
 @@ -11186,6 +11213,8 @@ fn zirCondbr(
     if (try sema.resolveDefinedValue(parent_block, src, cond)) |cond_val| {
         const body = if (cond_val.toBool()) then_body else else_body;
+        // We use `analyzeBodyInner` since we want to propagate any possible
+        // `error.ComptimeBreak` to the caller.
         return sema.analyzeBodyInner(parent_block, body);
     }
 @@ -11199,11 +11228,11 @@ fn zirCondbr(
     sub_block.runtime_index += 1;
     defer sub_block.instructions.deinit(gpa);
-    _ = try sema.analyzeBody(&sub_block, then_body);
+    try sema.analyzeBody(&sub_block, then_body);
     const true_instructions = sub_block.instructions.toOwnedSlice(gpa);
     defer gpa.free(true_instructions);
-    _ = try sema.analyzeBody(&sub_block, else_body);
+    try sema.analyzeBody(&sub_block, else_body);
     try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.CondBr).Struct.fields.len +
         true_instructions.len + sub_block.instructions.items.len);
     _ = try parent_block.addInst(.{
 @@ -19186,7 +19215,7 @@ fn semaStructFields(
     }
     if (body.len != 0) {
-        _ = try sema.analyzeBody(&block_scope, body);
+        try sema.analyzeBody(&block_scope, body);
     }
     try wip_captures.finalize();
 @@ -19360,7 +19389,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
     }
     if (body.len != 0) {
-        _ = try sema.analyzeBody(&block_scope, body);
+        try sema.analyzeBody(&block_scope, body);
     }
     try wip_captures.finalize();

test/behavior.zig+1

...	@@ -46,6 +46,7 @@ test {	...	@@ -46,6 +46,7 @@ test {
46	_ = @import("behavior/bugs/4954.zig");	46	_ = @import("behavior/bugs/4954.zig");
47	_ = @import("behavior/bugs/6850.zig");	47	_ = @import("behavior/bugs/6850.zig");
48	_ = @import("behavior/bugs/7250.zig");	48	_ = @import("behavior/bugs/7250.zig");
		49	_ = @import("behavior/bugs/11100.zig");
49	_ = @import("behavior/call.zig");	50	_ = @import("behavior/call.zig");
50	_ = @import("behavior/cast.zig");	51	_ = @import("behavior/cast.zig");
51	_ = @import("behavior/comptime_memory.zig");	52	_ = @import("behavior/comptime_memory.zig");

test/behavior/basic.zig+7

...	@@ -846,3 +846,10 @@ test "discarding the result of various expressions" {	...	@@ -846,3 +846,10 @@ test "discarding the result of various expressions" {
846	_ = while (S.bar()) \|some\| break some else {};	846	_ = while (S.bar()) \|some\| break some else {};
847	_ = for ("foo") \|char\| break char else {};	847	_ = for ("foo") \|char\| break char else {};
848	}	848	}
		849
		850	test "labeled block implicitly ends in a break" {
		851	var a = false;
		852	blk: {
		853	if (a) break :blk;
		854	}
		855	}

test/behavior/bugs/11100.zig created+11

...	@@ -0,0 +1,11 @@
1	const std = @import("std");
2	pub fn do() bool {
3	inline for (.{"a"}) \|_\| {
4	if (true) return false;
5	}
6	return true;
7	}
8
9	test "bug" {
10	try std.testing.expect(!do());
11	}