Commit 9f88b3ae891956e6f887f579ad4b32e83cb06ee2 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-08-09 11:38:47-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-01-29 14:27:17-07:00
log	9f88b3ae891956e6f887f579ad4b32e83cb06ee2
tree	6895949037b0907d8f29c197ea4329af19b19b66
parent	baf5b4bc86635dcb14725c578f058f4c4dc27b90

Merge pull request #16752 from jacobly0/generic-srclocs

Sema: fix issues with source locations of generic arguments

6 files changed, 147 insertions(+), 52 deletions(-)

src
- Module.zig
- Sema.zig
test
- cases
  - compile_errors
    builtin_call_with_invalid_param.zig
    generic_method_call_invalid_coercion.zig
    generic_method_call_with_invalid_param.zig
- compile_errors.zig

src/Module.zig+40-16

...	@@ -2133,10 +2133,40 @@ pub const SrcLoc = struct {	...	@@ -2133,10 +2133,40 @@ pub const SrcLoc = struct {
2133	.call_arg => \|call_arg\| {	2133	.call_arg => \|call_arg\| {
2134	const tree = try src_loc.file_scope.getTree(gpa);	2134	const tree = try src_loc.file_scope.getTree(gpa);
2135	const node = src_loc.declRelativeToNodeIndex(call_arg.call_node_offset);	2135	const node = src_loc.declRelativeToNodeIndex(call_arg.call_node_offset);
2136	var buf: [1]Ast.Node.Index = undefined;	2136	var buf: [2]Ast.Node.Index = undefined;
2137	const call_full = tree.fullCall(&buf, node).?;	2137	const call_full = tree.fullCall(buf[0..1], node) orelse {
2138	const src_node = call_full.ast.params[call_arg.arg_index];	2138	const node_tags = tree.nodes.items(.tag);
2139	return nodeToSpan(tree, src_node);	2139	assert(node_tags[node] == .builtin_call);
		2140	const call_args_node = tree.extra_data[tree.nodes.items(.data)[node].rhs - 1];
		2141	switch (node_tags[call_args_node]) {
		2142	.array_init_one,
		2143	.array_init_one_comma,
		2144	.array_init_dot_two,
		2145	.array_init_dot_two_comma,
		2146	.array_init_dot,
		2147	.array_init_dot_comma,
		2148	.array_init,
		2149	.array_init_comma,
		2150	=> {
		2151	const full = tree.fullArrayInit(&buf, call_args_node).?.ast.elements;
		2152	return nodeToSpan(tree, full[call_arg.arg_index]);
		2153	},
		2154	.struct_init_one,
		2155	.struct_init_one_comma,
		2156	.struct_init_dot_two,
		2157	.struct_init_dot_two_comma,
		2158	.struct_init_dot,
		2159	.struct_init_dot_comma,
		2160	.struct_init,
		2161	.struct_init_comma,
		2162	=> {
		2163	const full = tree.fullStructInit(&buf, call_args_node).?.ast.fields;
		2164	return nodeToSpan(tree, full[call_arg.arg_index]);
		2165	},
		2166	else => return nodeToSpan(tree, call_args_node),
		2167	}
		2168	};
		2169	return nodeToSpan(tree, call_full.ast.params[call_arg.arg_index]);
2140	},	2170	},
2141	.fn_proto_param => \|fn_proto_param\| {	2171	.fn_proto_param => \|fn_proto_param\| {
2142	const tree = try src_loc.file_scope.getTree(gpa);	2172	const tree = try src_loc.file_scope.getTree(gpa);
...	@@ -5926,21 +5956,15 @@ pub fn argSrc(	...	@@ -5926,21 +5956,15 @@ pub fn argSrc(
5926	});	5956	});
5927	return LazySrcLoc.nodeOffset(0);	5957	return LazySrcLoc.nodeOffset(0);
5928	};	5958	};
5929	const node_tags = tree.nodes.items(.tag);
5930	const node = decl.relativeToNodeIndex(call_node_offset);	5959	const node = decl.relativeToNodeIndex(call_node_offset);
5931	var args: [1]Ast.Node.Index = undefined;	5960	var args: [1]Ast.Node.Index = undefined;
5932	const full = switch (node_tags[node]) {	5961	const call_full = tree.fullCall(&args, node) orelse {
5933	.call_one, .call_one_comma, .async_call_one, .async_call_one_comma => tree.callOne(&args, node),	5962	assert(tree.nodes.items(.tag)[node] == .builtin_call);
5934	.call, .call_comma, .async_call, .async_call_comma => tree.callFull(node),	5963	const call_args_node = tree.extra_data[tree.nodes.items(.data)[node].rhs - 1];
5935	.builtin_call => {	5964	const call_args_offset = decl.nodeIndexToRelative(call_args_node);
5936	const node_datas = tree.nodes.items(.data);	5965	return mod.initSrc(call_args_offset, decl, arg_i);
5937	const call_args_node = tree.extra_data[node_datas[node].rhs - 1];
5938	const call_args_offset = decl.nodeIndexToRelative(call_args_node);
5939	return mod.initSrc(call_args_offset, decl, arg_i);
5940	},
5941	else => unreachable,
5942	};	5966	};
5943	return LazySrcLoc.nodeOffset(decl.nodeIndexToRelative(full.ast.params[arg_i]));	5967	return LazySrcLoc.nodeOffset(decl.nodeIndexToRelative(call_full.ast.params[arg_i]));
5944	}	5968	}
5945		5969
5946	pub fn initSrc(	5970	pub fn initSrc(

src/Sema.zig+29-15

 @@ -70,6 +70,7 @@ generic_owner: InternPool.Index = .none,
 /// instantiation can point back to the instantiation site in addition to the
 /// declaration site.
 generic_call_src: LazySrcLoc = .unneeded,
+generic_bound_arg_src: ?LazySrcLoc = null,
 /// Corresponds to `generic_call_src`.
 generic_call_decl: Decl.OptionalIndex = .none,
 /// The key is types that must be fully resolved prior to machine code
 @@ -7077,16 +7078,19 @@ fn analyzeCall(
         const parent_fn_ret_ty_ies = sema.fn_ret_ty_ies;
         const parent_generic_owner = sema.generic_owner;
         const parent_generic_call_src = sema.generic_call_src;
+        const parent_generic_bound_arg_src = sema.generic_bound_arg_src;
         const parent_generic_call_decl = sema.generic_call_decl;
         sema.fn_ret_ty = bare_return_type;
         sema.fn_ret_ty_ies = null;
         sema.generic_owner = .none;
         sema.generic_call_src = .unneeded;
+        sema.generic_bound_arg_src = null;
         sema.generic_call_decl = .none;
         defer sema.fn_ret_ty = parent_fn_ret_ty;
         defer sema.fn_ret_ty_ies = parent_fn_ret_ty_ies;
         defer sema.generic_owner = parent_generic_owner;
         defer sema.generic_call_src = parent_generic_call_src;
+        defer sema.generic_bound_arg_src = parent_generic_bound_arg_src;
         defer sema.generic_call_decl = parent_generic_call_decl;
         if (module_fn.analysis(ip).inferred_error_set) {
 @@ -7545,6 +7549,7 @@ fn instantiateGenericCall(
         .comptime_args = comptime_args,
         .generic_owner = generic_owner,
         .generic_call_src = call_src,
+        .generic_bound_arg_src = bound_arg_src,
         .generic_call_decl = block.src_decl.toOptional(),
         .branch_quota = sema.branch_quota,
         .branch_count = sema.branch_count,
 @@ -8583,17 +8588,20 @@ fn resolveGenericBody(
         const prev_no_partial_func_type = sema.no_partial_func_ty;
         const prev_generic_owner = sema.generic_owner;
         const prev_generic_call_src = sema.generic_call_src;
+        const prev_generic_bound_arg_src = sema.generic_bound_arg_src;
         const prev_generic_call_decl = sema.generic_call_decl;
         block.params = .{};
         sema.no_partial_func_ty = true;
         sema.generic_owner = .none;
         sema.generic_call_src = .unneeded;
+        sema.generic_bound_arg_src = null;
         sema.generic_call_decl = .none;
         defer {
             block.params = prev_params;
             sema.no_partial_func_ty = prev_no_partial_func_type;
             sema.generic_owner = prev_generic_owner;
             sema.generic_call_src = prev_generic_call_src;
+            sema.generic_bound_arg_src = prev_generic_bound_arg_src;
             sema.generic_call_decl = prev_generic_call_decl;
         }
 @@ -9211,6 +9219,21 @@ fn finishFunc(
     return Air.internedToRef(if (opt_func_index != .none) opt_func_index else func_ty);
 }
+fn genericArgSrcLoc(sema: *Sema, block: *Block, param_index: u32, param_src: LazySrcLoc) Module.SrcLoc {
+    const mod = sema.mod;
+    if (sema.generic_owner == .none) return param_src.toSrcLoc(mod.declPtr(block.src_decl), mod);
+    const arg_decl = sema.generic_call_decl.unwrap().?;
+    const arg_src: LazySrcLoc = if (param_index == 0 and sema.generic_bound_arg_src != null)
+        sema.generic_bound_arg_src.?
+    else
+        .{ .call_arg = .{
+            .decl = arg_decl,
+            .call_node_offset = sema.generic_call_src.node_offset.x,
+            .arg_index = param_index - @intFromBool(sema.generic_bound_arg_src != null),
+        } };
+    return arg_src.toSrcLoc(mod.declPtr(arg_decl), mod);
+}
 fn zirParam(
     sema: *Sema,
     block: *Block,
 @@ -9218,7 +9241,6 @@ fn zirParam(
     param_index: u32,
     comptime_syntax: bool,
 ) CompileError!void {
-    const mod = sema.mod;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
     const src = inst_data.src();
 @@ -9235,17 +9257,20 @@ fn zirParam(
             const prev_no_partial_func_type = sema.no_partial_func_ty;
             const prev_generic_owner = sema.generic_owner;
             const prev_generic_call_src = sema.generic_call_src;
+            const prev_generic_bound_arg_src = sema.generic_bound_arg_src;
             const prev_generic_call_decl = sema.generic_call_decl;
             block.params = .{};
             sema.no_partial_func_ty = true;
             sema.generic_owner = .none;
             sema.generic_call_src = .unneeded;
+            sema.generic_bound_arg_src = null;
             sema.generic_call_decl = .none;
             defer {
                 block.params = prev_params;
                 sema.no_partial_func_ty = prev_no_partial_func_type;
                 sema.generic_owner = prev_generic_owner;
                 sema.generic_call_src = prev_generic_call_src;
+                sema.generic_bound_arg_src = prev_generic_bound_arg_src;
                 sema.generic_call_decl = prev_generic_call_decl;
             }
 @@ -9319,13 +9344,8 @@ fn zirParam(
                 sema.comptime_args[param_index] = val.toIntern();
                 return;
             }
-            const arg_src: LazySrcLoc = if (sema.generic_call_src == .node_offset) .{ .call_arg = .{
-                .decl = sema.generic_call_decl.unwrap().?,
-                .call_node_offset = sema.generic_call_src.node_offset.x,
-                .arg_index = param_index,
-            } } else src;
             const msg = msg: {
-                const src_loc = arg_src.toSrcLoc(mod.declPtr(block.src_decl), mod);
+                const src_loc = sema.genericArgSrcLoc(block, param_index, src);
                 const msg = try Module.ErrorMsg.create(gpa, src_loc, "{s}", .{
                     @as([]const u8, "runtime-known argument passed to comptime parameter"),
                 });
 @@ -9371,7 +9391,6 @@ fn zirParamAnytype(
     param_index: u32,
     comptime_syntax: bool,
 ) CompileError!void {
-    const mod = sema.mod;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
     const param_name: Zir.NullTerminatedString = @enumFromInt(inst_data.start);
 @@ -9385,11 +9404,6 @@ fn zirParamAnytype(
             sema.comptime_args[param_index] = opv.toIntern();
             return;
         }
-        const arg_src: LazySrcLoc = if (sema.generic_call_src == .node_offset) .{ .call_arg = .{
-            .decl = sema.generic_call_decl.unwrap().?,
-            .call_node_offset = sema.generic_call_src.node_offset.x,
-            .arg_index = param_index,
-        } } else src;
         if (comptime_syntax) {
             if (try sema.resolveMaybeUndefVal(air_ref)) |val| {
 @@ -9397,7 +9411,7 @@ fn zirParamAnytype(
                 return;
             }
             const msg = msg: {
-                const src_loc = arg_src.toSrcLoc(mod.declPtr(block.src_decl), mod);
+                const src_loc = sema.genericArgSrcLoc(block, param_index, src);
                 const msg = try Module.ErrorMsg.create(gpa, src_loc, "{s}", .{
                     @as([]const u8, "runtime-known argument passed to comptime parameter"),
                 });
 @@ -9417,7 +9431,7 @@ fn zirParamAnytype(
                 return;
             }
             const msg = msg: {
-                const src_loc = arg_src.toSrcLoc(mod.declPtr(block.src_decl), mod);
+                const src_loc = sema.genericArgSrcLoc(block, param_index, src);
                 const msg = try Module.ErrorMsg.create(gpa, src_loc, "{s}", .{
                     @as([]const u8, "runtime-known argument passed to comptime-only type parameter"),
                 });

test/cases/compile_errors/builtin_call_with_invalid_param.zig created+12

...	@@ -0,0 +1,12 @@
1	export fn builtinCallBoolFunctionInlineWithVoid() void {
2	@call(.always_inline, boolFunction, .{{}});
3	}
4
5	fn boolFunction(_: bool) void {}
6
7	// error
8	// backend=stage2
9	// target=native
10	//
11	// :2:43: error: expected type 'bool', found 'void'
12	// :5:20: note: parameter type declared here

test/cases/compile_errors/generic_method_call_invalid_coercion.zig deleted-21

...	@@ -1,21 +0,0 @@
1	export fn callBoolMethod() void {
2	const s = S{};
3	s.boolMethod({});
4	}
5
6	export fn callVoidMethod() void {
7	const s = S{};
8	s.voidMethod(false);
9	}
10
11	const S = struct {
12	fn boolMethod(comptime _: @This(), _: bool) void {}
13	fn voidMethod(comptime _: @This(), _: void) void {}
14	};
15
16	// error
17	// backend=stage2
18	// target=native
19	//
20	// :3:18: error: expected type 'bool', found 'void'
21	// :8:18: error: expected type 'void', found 'bool'

test/cases/compile_errors/generic_method_call_with_invalid_param.zig created+30

...	@@ -0,0 +1,30 @@
1	export fn callBoolMethodWithVoid() void {
2	const s = S{};
3	s.boolMethod({});
4	}
5
6	export fn callVoidMethodWithBool() void {
7	const s = S{};
8	s.voidMethod(false);
9	}
10
11	export fn callComptimeBoolMethodWithRuntimeBool() void {
12	const s = S{};
13	var arg = true;
14	s.comptimeBoolMethod(arg);
15	}
16
17	const S = struct {
18	fn boolMethod(comptime _: @This(), _: bool) void {}
19	fn voidMethod(comptime _: @This(), _: void) void {}
20	fn comptimeBoolMethod(comptime _: @This(), comptime _: bool) void {}
21	};
22
23	// error
24	// backend=stage2
25	// target=native
26	//
27	// :3:18: error: expected type 'bool', found 'void'
28	// :8:18: error: expected type 'void', found 'bool'
29	// :14:26: error: runtime-known argument passed to comptime parameter
30	// :20:57: note: declared comptime here

test/compile_errors.zig+36

...	@@ -183,4 +183,40 @@ pub fn addCases(ctx: *Cases) !void {	...	@@ -183,4 +183,40 @@ pub fn addCases(ctx: *Cases) !void {
183	":1:1: note: invalid byte: '\\xff'",	183	":1:1: note: invalid byte: '\\xff'",
184	});	184	});
185	}	185	}
		186
		187	{
		188	const case = ctx.obj("imported generic method call with invalid param", .{});
		189
		190	case.addError(
		191	\\pub const import = @import("import.zig");
		192	\\
		193	\\export fn callComptimeBoolFunctionWithRuntimeBool(x: bool) void {
		194	\\ import.comptimeBoolFunction(x);
		195	\\}
		196	\\
		197	\\export fn callComptimeAnytypeFunctionWithRuntimeBool(x: bool) void {
		198	\\ import.comptimeAnytypeFunction(x);
		199	\\}
		200	\\
		201	\\export fn callAnytypeFunctionWithRuntimeComptimeOnlyType(x: u32) void {
		202	\\ const S = struct { x: u32, y: type };
		203	\\ import.anytypeFunction(S{ .x = x, .y = u32 });
		204	\\}
		205	, &[_][]const u8{
		206	":4:33: error: runtime-known argument passed to comptime parameter",
		207	":1:38: note: declared comptime here",
		208	":8:36: error: runtime-known argument passed to comptime parameter",
		209	":2:41: note: declared comptime here",
		210	":13:29: error: runtime-known argument passed to comptime-only type parameter",
		211	":3:24: note: declared here",
		212	":12:35: note: struct requires comptime because of this field",
		213	":12:35: note: types are not available at runtime",
		214	});
		215
		216	case.addSourceFile("import.zig",
		217	\\pub fn comptimeBoolFunction(comptime _: bool) void {}
		218	\\pub fn comptimeAnytypeFunction(comptime _: anytype) void {}
		219	\\pub fn anytypeFunction(_: anytype) void {}
		220	);
		221	}
186	}	222	}