Commit 9821a0c6f0caf3df4cc6000c000d9cc38baf27d8 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-03-29 20:11:48-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-03-29 20:11:48-07:00
log	9821a0c6f0caf3df4cc6000c000d9cc38baf27d8
tree	baa31bbf0e3fc3a5cbed557eb2a800ccbf2b55d6
parent	e39c86399da565d3855d54b242bf7b5940e3924d

Sema: fix generic instantiations of return types with nested captures

 * In semaStructFields and semaUnionFields we return error.GenericPoison
   if one of the field types ends up being generic poison.
   - This requires handling function calls and function types taking
     this into account when calling `typeRequiresComptime` on the return
     type.
 * Unrelated: I noticed using Valgrind that struct reification did not
   populate the `known_opv` field. After fixing it, the behavior tests
   run Valgrind-clean.
 * ZIR: use `@ptrCast` to cast between slices instead of exploiting
   the fact that stage1 incorrectly allows `@bitCast` between slices.
   - A future enhancement will make Zig support `@ptrCast` to directly
     cast between slices.

3 files changed, 52 insertions(+), 9 deletions(-)

src
- Sema.zig
- Zir.zig
test
- behavior
  - generics.zig

src/Sema.zig+33-7

 @@ -4764,12 +4764,20 @@ fn analyzeCall(
     const gpa = sema.gpa;
-    var is_comptime_call = block.is_comptime or modifier == .compile_time or
+    var is_generic_call = func_ty_info.is_generic;
-        try sema.typeRequiresComptime(block, func_src, func_ty_info.return_type);
+    var is_comptime_call = block.is_comptime or modifier == .compile_time;
+    if (!is_comptime_call) {
+        if (sema.typeRequiresComptime(block, func_src, func_ty_info.return_type)) |ct| {
+            is_comptime_call = ct;
+        } else |err| switch (err) {
+            error.GenericPoison => is_generic_call = true,
+            else => |e| return e,
+        }
+    }
     var is_inline_call = is_comptime_call or modifier == .always_inline or
         func_ty_info.cc == .Inline;
-    if (!is_inline_call and func_ty_info.is_generic) {
+    if (!is_inline_call and is_generic_call) {
         if (sema.instantiateGenericCall(
             block,
             func,
 @@ -6410,10 +6418,20 @@ fn funcCommon(
             }
         }
-        is_generic = is_generic or
+        const ret_poison = if (!is_generic) rp: {
-            try sema.typeRequiresComptime(block, ret_ty_src, bare_return_type);
+            if (sema.typeRequiresComptime(block, ret_ty_src, bare_return_type)) |ret_comptime| {
+                is_generic = ret_comptime;
+                break :rp bare_return_type.tag() == .generic_poison;
+            } else |err| switch (err) {
+                error.GenericPoison => {
+                    is_generic = true;
+                    break :rp true;
+                },
+                else => |e| return e,
+            }
+        } else bare_return_type.tag() == .generic_poison;
-        const return_type = if (!inferred_error_set or bare_return_type.tag() == .generic_poison)
+        const return_type = if (!inferred_error_set or ret_poison)
             bare_return_type
         else blk: {
             const node = try sema.gpa.create(Module.Fn.InferredErrorSetListNode);
 @@ -13570,7 +13588,7 @@ fn reifyStruct(
         .zir_index = inst,
         .layout = layout_val.toEnum(std.builtin.Type.ContainerLayout),
         .status = .have_field_types,
-        .known_non_opv = undefined,
+        .known_non_opv = false,
         .namespace = .{
             .parent = block.namespace,
             .ty = struct_ty,
 @@ -21666,6 +21684,10 @@ fn semaStructFields(
         // TODO emit compile errors for invalid field types
         // such as arrays and pointers inside packed structs.
+        if (field_ty.tag() == .generic_poison) {
+            return error.GenericPoison;
+        }
         const gop = struct_obj.fields.getOrPutAssumeCapacity(field_name);
         assert(!gop.found_existing);
         gop.value_ptr.* = .{
 @@ -21913,6 +21935,10 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
             // But only resolve the source location if we need to emit a compile error.
             try sema.resolveType(&block_scope, src, field_type_ref);
+        if (field_ty.tag() == .generic_poison) {
+            return error.GenericPoison;
+        }
         const gop = union_obj.fields.getOrPutAssumeCapacity(field_name);
         assert(!gop.found_existing);
         gop.value_ptr.* = .{

src/Zir.zig+3-2

...	@@ -63,7 +63,7 @@ pub const ExtraIndex = enum(u32) {	...	@@ -63,7 +63,7 @@ pub const ExtraIndex = enum(u32) {
63	/// Returns the requested data, as well as the new index which is at the start of the	63	/// Returns the requested data, as well as the new index which is at the start of the
64	/// trailers for the object.	64	/// trailers for the object.
65	pub fn extraData(code: Zir, comptime T: type, index: usize) struct { data: T, end: usize } {	65	pub fn extraData(code: Zir, comptime T: type, index: usize) struct { data: T, end: usize } {
66	const fields = std.meta.fields(T);	66	const fields = @typeInfo(T).Struct.fields;
67	var i: usize = index;	67	var i: usize = index;
68	var result: T = undefined;	68	var result: T = undefined;
69	inline for (fields) \|field\| {	69	inline for (fields) \|field\| {
...	@@ -94,7 +94,8 @@ pub fn nullTerminatedString(code: Zir, index: usize) [:0]const u8 {	...	@@ -94,7 +94,8 @@ pub fn nullTerminatedString(code: Zir, index: usize) [:0]const u8 {
94		94
95	pub fn refSlice(code: Zir, start: usize, len: usize) []Inst.Ref {	95	pub fn refSlice(code: Zir, start: usize, len: usize) []Inst.Ref {
96	const raw_slice = code.extra[start..][0..len];	96	const raw_slice = code.extra[start..][0..len];
97	return @bitCast([]Inst.Ref, raw_slice);	97	// TODO we should be able to directly `@ptrCast` the slice to the other slice type.
		98	return @ptrCast([*]Inst.Ref, raw_slice.ptr)[0..len];
98	}	99	}
99		100
100	pub fn hasCompileErrors(code: Zir) bool {	101	pub fn hasCompileErrors(code: Zir) bool {

test/behavior/generics.zig+16

...	@@ -290,3 +290,19 @@ test "generic function with void and comptime parameter" {	...	@@ -290,3 +290,19 @@ test "generic function with void and comptime parameter" {
290	var s: S = .{ .x = 1234 };	290	var s: S = .{ .x = 1234 };
291	try namespace.foo({}, &s, u8);	291	try namespace.foo({}, &s, u8);
292	}	292	}
		293
		294	test "anonymous struct return type referencing comptime parameter" {
		295	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		296
		297	const S = struct {
		298	pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } {
		299	return .{
		300	.data = 1234,
		301	.end = index,
		302	};
		303	}
		304	};
		305	const s = S.extraData(i32, 5678);
		306	try expect(s.data == 1234);
		307	try expect(s.end == 5678);
		308	}