Commit 7a881435ed54b0cf59f48679c3912600b3bd0d58 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-08-24 15:59:46-04:00
committer	GitHub <noreply@github.com> 2022-08-24 15:59:46-04:00
log	7a881435ed54b0cf59f48679c3912600b3bd0d58
tree	551acc0660ddd455edcc6ee4ab4644b7a9bc8363
parent	2a96209c4060bbf8a41fbe34e687a7a4741d2fe1
parent	69a3c4e279238874cc74cf6acd5eb0426d5b65ee
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #12623 from Vexu/stage2-fixes

Stage2 fixes

8 files changed, 86 insertions(+), 30 deletions(-)

src
test
- behavior
  - generics.zig
  - tuple.zig
- cases
  - compile_errors
    comptime_parameter_not_declared_as_such.zig
    error_in_typeof_param.zig
    slice_of_non_array_type.zig

src/AstGen.zig+4-2

 @@ -4265,10 +4265,13 @@ fn structDeclInner(
     // are in scope, so that field types, alignments, and default value expressions
     // can refer to decls within the struct itself.
     astgen.advanceSourceCursorToNode(node);
+    // If `node == 0` then this is the root struct and all the declarations should
+    // be relative to the beginning of the file.
+    const decl_line = if (node == 0) 0 else astgen.source_line;
     var block_scope: GenZir = .{
         .parent = &namespace.base,
         .decl_node_index = node,
-        .decl_line = astgen.source_line,
+        .decl_line = decl_line,
         .astgen = astgen,
         .force_comptime = true,
         .in_defer = false,
 @@ -11756,7 +11759,6 @@ fn scanDecls(astgen: *AstGen, namespace: *Scope.Namespace, members: []const Ast.
             }
         }
-        // const index_name = try astgen.identAsString(index_token);
         var s = namespace.parent;
         while (true) switch (s.tag) {
             .local_val => {

src/Sema.zig+23-25

 @@ -78,6 +78,9 @@ post_hoc_blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, *LabeledBlock) = .{},
 err: ?*Module.ErrorMsg = null,
 /// True when analyzing a generic instantiation. Used to suppress some errors.
 is_generic_instantiation: bool = false,
+/// Set to true when analyzing a func type instruction so that nested generic
+/// function types will emit generic poison instead of a partial type.
+no_partial_func_ty: bool = false,
 const std = @import("std");
 const math = std.math;
 @@ -4068,6 +4071,19 @@ fn zirValidateArrayInit(
         // Determine whether the value stored to this pointer is comptime-known.
+        if (array_ty.isTuple()) {
+            if (array_ty.structFieldValueComptime(i)) |opv| {
+                element_vals[i] = opv;
+                continue;
+            }
+        } else {
+            // Array has one possible value, so value is always 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
 @@ -4084,19 +4100,6 @@ fn zirValidateArrayInit(
         }
         first_block_index = @minimum(first_block_index, block_index);
-        if (array_ty.isTuple()) {
-            if (array_ty.structFieldValueComptime(i)) |opv| {
-                element_vals[i] = opv;
-                continue;
-            }
-        } else {
-            // 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.
         const next_air_inst = block.instructions.items[block_index + 1];
 @@ -5938,10 +5941,9 @@ fn analyzeCall(
                 undefined,
             ) catch |err| switch (err) {
                 error.NeededSourceLocation => {
-                    sema.inst_map.clearRetainingCapacity();
+                    _ = sema.inst_map.remove(inst);
                     const decl = sema.mod.declPtr(block.src_decl);
                     child_block.src_decl = block.src_decl;
-                    arg_i = 0;
                     try sema.analyzeInlineCallArg(
                         block,
                         &child_block,
 @@ -7917,6 +7919,7 @@ fn funcCommon(
         if (cc_workaround == .Inline and is_noinline) {
             return sema.fail(block, cc_src, "'noinline' function cannot have callconv 'Inline'", .{});
         }
+        if (is_generic and sema.no_partial_func_ty) return error.GenericPoison;
         break :fn_ty try Type.Tag.function.create(sema.arena, .{
             .param_types = param_types,
 @@ -8097,25 +8100,19 @@ fn zirParam(
             // Make sure any nested param instructions don't clobber our work.
             const prev_params = block.params;
             const prev_preallocated_new_func = sema.preallocated_new_func;
+            const prev_no_partial_func_type = sema.no_partial_func_ty;
             block.params = .{};
             sema.preallocated_new_func = null;
+            sema.no_partial_func_ty = true;
             defer {
                 block.params.deinit(sema.gpa);
                 block.params = prev_params;
                 sema.preallocated_new_func = prev_preallocated_new_func;
+                sema.no_partial_func_ty = prev_no_partial_func_type;
             }
             if (sema.resolveBody(block, body, inst)) |param_ty_inst| {
                 if (sema.analyzeAsType(block, src, param_ty_inst)) |param_ty| {
-                    if (param_ty.zigTypeTag() == .Fn and param_ty.fnInfo().is_generic) {
-                        // zirFunc will not emit error.GenericPoison to build a
-                        // partial type for generic functions but we still need to
-                        // detect if a function parameter is a generic function
-                        // to force the parent function to also be generic.
-                        if (!sema.inst_map.contains(inst)) {
-                            break :err error.GenericPoison;
-                        }
-                    }
                     break :param_ty param_ty;
                 } else |err| break :err err;
             } else |err| break :err err;
 @@ -26140,11 +26137,12 @@ fn analyzeSlice(
     var array_ty = ptr_ptr_child_ty;
     var slice_ty = ptr_ptr_ty;
     var ptr_or_slice = ptr_ptr;
-    var elem_ty = ptr_ptr_child_ty.childType();
+    var elem_ty: Type = undefined;
     var ptr_sentinel: ?Value = null;
     switch (ptr_ptr_child_ty.zigTypeTag()) {
         .Array => {
             ptr_sentinel = ptr_ptr_child_ty.sentinel();
+            elem_ty = ptr_ptr_child_ty.childType();
         },
         .Pointer => switch (ptr_ptr_child_ty.ptrSize()) {
             .One => {

src/value.zig+6

...	@@ -2689,6 +2689,12 @@ pub const Value = extern union {	...	@@ -2689,6 +2689,12 @@ pub const Value = extern union {
2689	// to have only one possible value itself.	2689	// to have only one possible value itself.
2690	.the_only_possible_value => return val,	2690	.the_only_possible_value => return val,
2691		2691
		2692	// pointer to integer casted to pointer of array
		2693	.int_u64, .int_i64 => {
		2694	assert(index == 0);
		2695	return val;
		2696	},
		2697
2692	else => unreachable,	2698	else => unreachable,
2693	}	2699	}
2694	}	2700	}

test/behavior/generics.zig+15

...	@@ -342,3 +342,18 @@ test "generic instantiation of tagged union with only one field" {	...	@@ -342,3 +342,18 @@ test "generic instantiation of tagged union with only one field" {
342	try expect(S.foo(.{ .s = "a" }) == 1);	342	try expect(S.foo(.{ .s = "a" }) == 1);
343	try expect(S.foo(.{ .s = "ab" }) == 2);	343	try expect(S.foo(.{ .s = "ab" }) == 2);
344	}	344	}
		345
		346	test "nested generic function" {
		347	const S = struct {
		348	fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void {
		349	try callback(data);
		350	}
		351	fn bar(a: u32) anyerror!void {
		352	try expect(a == 123);
		353	}
		354
		355	fn g(_: *const fn (anytype) void) void {}
		356	};
		357	try expect(@typeInfo(@TypeOf(S.g)).Fn.is_generic);
		358	try S.foo(u32, S.bar, 123);
		359	}

test/behavior/tuple.zig+11

...	@@ -290,3 +290,14 @@ test "coerce tuple to tuple" {	...	@@ -290,3 +290,14 @@ test "coerce tuple to tuple" {
290	};	290	};
291	try S.foo(.{123});	291	try S.foo(.{123});
292	}	292	}
		293
		294	test "tuple type with void field" {
		295	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
		296	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		297	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		298	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
		299
		300	const T = std.meta.Tuple(&[_]type{void});
		301	const x = T{{}};
		302	try expect(@TypeOf(x[0]) == void);
		303	}

test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig+4-3

...	@@ -1,5 +1,6 @@	...	@@ -1,5 +1,6 @@
1	fn f(_: anytype) void {}	1	fn f(_: anytype) void {}
2	fn g(h: *const fn (anytype) void) void {	2	const T = *const fn (anytype) void;
		3	fn g(h: T) void {
3	h({});	4	h({});
4	}	5	}
5	pub export fn entry() void {	6	pub export fn entry() void {
...	@@ -19,5 +20,5 @@ pub export fn entry1() void {	...	@@ -19,5 +20,5 @@ pub export fn entry1() void {
19	// backend=stage2	20	// backend=stage2
20	// target=native	21	// target=native
21	//	22	//
22	// :2:6: error: parameter of type '*const fn(anytype) void' must be declared comptime	23	// :3:6: error: parameter of type '*const fn(anytype) void' must be declared comptime
23	// :9:34: error: parameter of type 'comptime_int' must be declared comptime	24	// :10:34: error: parameter of type 'comptime_int' must be declared comptime

test/cases/compile_errors/error_in_typeof_param.zig created+14

...	@@ -0,0 +1,14 @@
1	fn getSize() usize {
2	return 2;
3	}
4	pub fn expectEqual(expected: anytype, _: @TypeOf(expected)) !void {}
5	pub export fn entry() void {
6	try expectEqual(2, getSize());
7	}
8
9	// error
10	// backend=stage2
11	// target=native
12	//
13	// :6:31: error: unable to resolve comptime value
14	// :6:31: note: argument to parameter with comptime only type must be comptime known

test/cases/compile_errors/slice_of_non_array_type.zig created+9

...	@@ -0,0 +1,9 @@
1	comptime {
2	_ = 1[0..];
3	}
4
5	// error
6	// backend=stage2
7	// target=native
8	//
9	// :2:10: error: slice of non-array type 'comptime_int'