Commit 1149e8bb088f48e29f3abc06196b1134f5e1c42f | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-03-15 20:03:58-04:00
committer	GitHub <noreply@github.com> 2022-03-15 20:03:58-04:00
log	1149e8bb088f48e29f3abc06196b1134f5e1c42f
tree	b3637be2086b25649d71e2d24d334aa634e87e03
parent	7d0b6956c0935807f0e5862c45da857e8e065c6b
parent	480e7eec65c02952b71ecc2f4ff2adccb6092a5f
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11185 from topolarity/bugfix-11159

stage2: resolve panic on array-like tuple initialization

8 files changed, 72 insertions(+), 13 deletions(-)

src
- AstGen.zig
- Sema.zig
- codegen
  - llvm.zig
- type.zig
test
- behavior.zig
- behavior
  - bugs
    11159.zig
    11162.zig
    11182.zig

src/AstGen.zig+7-5

 @@ -4092,15 +4092,17 @@ fn structDeclInner(
         const doc_comment_index = try astgen.docCommentAsString(member.firstToken());
         wip_members.appendToField(doc_comment_index);
-        known_non_opv = known_non_opv or
-            nodeImpliesMoreThanOnePossibleValue(tree, member.ast.type_expr);
-        known_comptime_only = known_comptime_only or
-            nodeImpliesComptimeOnly(tree, member.ast.type_expr);
         const have_align = member.ast.align_expr != 0;
         const have_value = member.ast.value_expr != 0;
         const is_comptime = member.comptime_token != null;
         const unused = false;
+        if (!is_comptime) {
+            known_non_opv = known_non_opv or
+                nodeImpliesMoreThanOnePossibleValue(tree, member.ast.type_expr);
+            known_comptime_only = known_comptime_only or
+                nodeImpliesComptimeOnly(tree, member.ast.type_expr);
+        }
         wip_members.nextField(bits_per_field, .{ have_align, have_value, is_comptime, unused });
         if (have_align) {

src/Sema.zig+8-5

 @@ -3203,11 +3203,6 @@ fn zirValidateArrayInit(
         // Determine whether the value stored to this pointer is comptime-known.
-        if (opt_opv) |opv| {
-            element_vals[i] = opv;
-            continue;
-        }
         const elem_ptr_air_ref = sema.inst_map.get(elem_ptr).?;
         const elem_ptr_air_inst = Air.refToIndex(elem_ptr_air_ref).?;
         // Find the block index of the elem_ptr so that we can look at the next
 @@ -3223,6 +3218,12 @@ fn zirValidateArrayInit(
             break :inst block.instructions.items[block_index + 1];
         };
+        // Array has one possible value, so value is always comptime-known
+        if (opt_opv) |opv| {
+            element_vals[i] = opv;
+            continue;
+        }
         // If the next instructon is a store with a comptime operand, this element
         // is comptime.
         switch (air_tags[next_air_inst]) {
 @@ -20860,6 +20861,7 @@ pub fn typeHasOnePossibleValue(
             const resolved_ty = try sema.resolveTypeFields(block, src, ty);
             const s = resolved_ty.castTag(.@"struct").?.data;
             for (s.fields.values()) |value| {
+                if (value.is_comptime) continue;
                 if ((try sema.typeHasOnePossibleValue(block, src, value.ty)) == null) {
                     return null;
                 }
 @@ -21532,6 +21534,7 @@ fn typeRequiresComptime(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) C
                     struct_obj.requires_comptime = .wip;
                     for (struct_obj.fields.values()) |field| {
+                        if (field.is_comptime) continue;
                         if (try sema.typeRequiresComptime(block, src, field.ty)) {
                             struct_obj.requires_comptime = .yes;
                             return true;

src/codegen/llvm.zig+4-3

 @@ -5422,21 +5422,22 @@ pub const FuncGen = struct {
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
         const dest_ptr = try self.resolveInst(bin_op.lhs);
         const ptr_ty = self.air.typeOf(bin_op.lhs);
+        const operand_ty = ptr_ty.childType();
+        if (!operand_ty.isFnOrHasRuntimeBitsIgnoreComptime()) return null;
         // TODO Sema should emit a different instruction when the store should
         // possibly do the safety 0xaa bytes for undefined.
         const val_is_undef = if (self.air.value(bin_op.rhs)) |val| val.isUndefDeep() else false;
         if (val_is_undef) {
-            const elem_ty = ptr_ty.childType();
             const target = self.dg.module.getTarget();
-            const elem_size = elem_ty.abiSize(target);
+            const operand_size = operand_ty.abiSize(target);
             const u8_llvm_ty = self.context.intType(8);
             const ptr_u8_llvm_ty = u8_llvm_ty.pointerType(0);
             const dest_ptr_u8 = self.builder.buildBitCast(dest_ptr, ptr_u8_llvm_ty, "");
             const fill_char = u8_llvm_ty.constInt(0xaa, .False);
             const dest_ptr_align = ptr_ty.ptrAlignment(target);
             const usize_llvm_ty = try self.dg.llvmType(Type.usize);
-            const len = usize_llvm_ty.constInt(elem_size, .False);
+            const len = usize_llvm_ty.constInt(operand_size, .False);
             _ = self.builder.buildMemSet(dest_ptr_u8, fill_char, len, dest_ptr_align, ptr_ty.isVolatilePtr());
             if (self.dg.module.comp.bin_file.options.valgrind) {
                 // TODO generate valgrind client request to mark byte range as undefined

src/type.zig+1

...	@@ -2098,6 +2098,7 @@ pub const Type = extern union {	...	@@ -2098,6 +2098,7 @@ pub const Type = extern union {
2098	}	2098	}
2099	assert(struct_obj.haveFieldTypes());	2099	assert(struct_obj.haveFieldTypes());
2100	for (struct_obj.fields.values()) \|value\| {	2100	for (struct_obj.fields.values()) \|value\| {
		2101	if (value.is_comptime) continue;
2101	if (value.ty.hasRuntimeBitsAdvanced(ignore_comptime_only))	2102	if (value.ty.hasRuntimeBitsAdvanced(ignore_comptime_only))
2102	return true;	2103	return true;
2103	} else {	2104	} else {

test/behavior.zig+3

 @@ -65,8 +65,11 @@ test {
     _ = @import("behavior/bugs/10970.zig");
     _ = @import("behavior/bugs/11046.zig");
     _ = @import("behavior/bugs/11139.zig");
+    _ = @import("behavior/bugs/11159.zig");
+    _ = @import("behavior/bugs/11162.zig");
     _ = @import("behavior/bugs/11165.zig");
     _ = @import("behavior/bugs/11181.zig");
+    _ = @import("behavior/bugs/11182.zig");
     _ = @import("behavior/call.zig");
     _ = @import("behavior/cast.zig");
     _ = @import("behavior/comptime_memory.zig");

test/behavior/bugs/11159.zig created+23

...	@@ -0,0 +1,23 @@
1	const std = @import("std");
2	const builtin = @import("builtin");
3
4	test {
5	const T = @TypeOf(.{ @as(i32, 0), @as(u32, 0) });
6	var a: T = .{ 0, 0 };
7	_ = a;
8	}
9
10	test {
11	if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
12	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
13	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
14
15	const S = struct {
16	comptime x: i32 = 0,
17	comptime y: u32 = 0,
18	};
19	var a: S = .{};
20	_ = a;
21	var b = S{};
22	_ = b;
23	}

test/behavior/bugs/11162.zig created+16

...	@@ -0,0 +1,16 @@
1	const std = @import("std");
2	const builtin = @import("builtin");
3	const expect = std.testing.expect;
4
5	test {
6	if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
8
9	var x: u32 = 15;
10	const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
11	var a: T = .{ -1234, 5678, x + 1 };
12
13	try expect(a[0] == -1234);
14	try expect(a[1] == 5678);
15	try expect(a[2] == 16);
16	}

test/behavior/bugs/11182.zig created+10

...	@@ -0,0 +1,10 @@
1	const std = @import("std");
2	const builtin = @import("builtin");
3
4	test {
5	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
6
7	const T = @TypeOf(.{ @as(i32, 0), @as(u32, 0) });
8	var a = T{ 0, 0 };
9	_ = a;
10	}