authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2022-07-19 20:20:57+03:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-07-21 12:21:30-07:00
log79ef0cdf306c48d3cc447ce14530db4021f8c5de
treed97ae5e97c97e0f3545b0d1e80af1ecf4cbf0492
parent83b2d2cd3eb701b43d17404e73933bc00f7be828

Sema: better function parameter source location

14 files changed, 256 insertions(+), 109 deletions(-)

src/Module.zig+85
......@@ -2482,6 +2482,41 @@ pub const SrcLoc = struct {
24822482 };
24832483 return nodeToSpan(tree, full.ast.return_type);
24842484 },
2485 .node_offset_param => |node_off| {
2486 const tree = try src_loc.file_scope.getTree(gpa);
2487 const token_tags = tree.tokens.items(.tag);
2488 const node = src_loc.declRelativeToNodeIndex(node_off);
2489
2490 var first_tok = tree.firstToken(node);
2491 while (true) switch (token_tags[first_tok - 1]) {
2492 .colon, .identifier, .keyword_comptime, .keyword_noalias => first_tok -= 1,
2493 else => break,
2494 };
2495 return tokensToSpan(
2496 tree,
2497 first_tok,
2498 tree.lastToken(node),
2499 first_tok,
2500 );
2501 },
2502 .token_offset_param => |token_off| {
2503 const tree = try src_loc.file_scope.getTree(gpa);
2504 const token_tags = tree.tokens.items(.tag);
2505 const main_token = tree.nodes.items(.main_token)[src_loc.parent_decl_node];
2506 const tok_index = @bitCast(Ast.TokenIndex, token_off + @bitCast(i32, main_token));
2507
2508 var first_tok = tok_index;
2509 while (true) switch (token_tags[first_tok - 1]) {
2510 .colon, .identifier, .keyword_comptime, .keyword_noalias => first_tok -= 1,
2511 else => break,
2512 };
2513 return tokensToSpan(
2514 tree,
2515 first_tok,
2516 tok_index,
2517 first_tok,
2518 );
2519 },
24852520
24862521 .node_offset_anyframe_type => |node_off| {
24872522 const tree = try src_loc.file_scope.getTree(gpa);
......@@ -2930,6 +2965,8 @@ pub const LazySrcLoc = union(enum) {
29302965 /// the return type node.
29312966 /// The Decl is determined contextually.
29322967 node_offset_fn_type_ret_ty: i32,
2968 node_offset_param: i32,
2969 token_offset_param: i32,
29332970 /// The source location points to the type expression of an `anyframe->T`
29342971 /// expression, found by taking this AST node index offset from the containing
29352972 /// Decl AST node, which points to a `anyframe->T` expression AST node. Next, navigate
......@@ -3046,6 +3083,8 @@ pub const LazySrcLoc = union(enum) {
30463083 .node_offset_fn_type_section,
30473084 .node_offset_fn_type_cc,
30483085 .node_offset_fn_type_ret_ty,
3086 .node_offset_param,
3087 .token_offset_param,
30493088 .node_offset_anyframe_type,
30503089 .node_offset_lib_name,
30513090 .node_offset_array_type_len,
......@@ -5826,6 +5865,52 @@ fn queryFieldSrc(
58265865 unreachable;
58275866}
58285867
5868pub fn paramSrc(
5869 func_node_offset: i32,
5870 gpa: Allocator,
5871 decl: *Decl,
5872 param_i: usize,
5873) LazySrcLoc {
5874 @setCold(true);
5875 const tree = decl.getFileScope().getTree(gpa) catch |err| {
5876 // In this case we emit a warning + a less precise source location.
5877 log.warn("unable to load {s}: {s}", .{
5878 decl.getFileScope().sub_file_path, @errorName(err),
5879 });
5880 return LazySrcLoc.nodeOffset(0);
5881 };
5882 const node_datas = tree.nodes.items(.data);
5883 const node_tags = tree.nodes.items(.tag);
5884 const node = decl.relativeToNodeIndex(func_node_offset);
5885 var params: [1]Ast.Node.Index = undefined;
5886 const full = switch (node_tags[node]) {
5887 .fn_proto_simple => tree.fnProtoSimple(&params, node),
5888 .fn_proto_multi => tree.fnProtoMulti(node),
5889 .fn_proto_one => tree.fnProtoOne(&params, node),
5890 .fn_proto => tree.fnProto(node),
5891 .fn_decl => switch (node_tags[node_datas[node].lhs]) {
5892 .fn_proto_simple => tree.fnProtoSimple(&params, node_datas[node].lhs),
5893 .fn_proto_multi => tree.fnProtoMulti(node_datas[node].lhs),
5894 .fn_proto_one => tree.fnProtoOne(&params, node_datas[node].lhs),
5895 .fn_proto => tree.fnProto(node_datas[node].lhs),
5896 else => unreachable,
5897 },
5898 else => unreachable,
5899 };
5900 var it = full.iterate(tree);
5901 while (true) {
5902 if (it.param_i == param_i) {
5903 const param = it.next().?;
5904 if (param.anytype_ellipsis3) |some| {
5905 const main_token = tree.nodes.items(.main_token)[decl.src_node];
5906 return .{ .token_offset_param = @bitCast(i32, some) - @bitCast(i32, main_token) };
5907 }
5908 return .{ .node_offset_param = decl.nodeIndexToRelative(param.type_expr) };
5909 }
5910 _ = it.next();
5911 }
5912}
5913
58295914/// Called from `performAllTheWork`, after all AstGen workers have finished,
58305915/// and before the main semantic analysis loop begins.
58315916pub fn processOutdatedAndDeletedDecls(mod: *Module) !void {
src/Sema.zig+104-54
......@@ -7233,6 +7233,7 @@ fn funcCommon(
72337233 opt_lib_name: ?[]const u8,
72347234 noalias_bits: u32,
72357235) CompileError!Air.Inst.Ref {
7236 const fn_src = LazySrcLoc.nodeOffset(src_node_offset);
72367237 const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
72377238 const cc_src: LazySrcLoc = .{ .node_offset_fn_type_cc = src_node_offset };
72387239
......@@ -7241,10 +7242,6 @@ fn funcCommon(
72417242 address_space == null or
72427243 section == .generic or
72437244 cc == null;
7244 // Check for generic params.
7245 for (block.params.items) |param| {
7246 if (param.ty.tag() == .generic_poison) is_generic = true;
7247 }
72487245
72497246 var destroy_fn_on_error = false;
72507247 const new_func: *Module.Fn = new_func: {
......@@ -7304,55 +7301,35 @@ fn funcCommon(
73047301 const param_types = try sema.arena.alloc(Type, block.params.items.len);
73057302 const comptime_params = try sema.arena.alloc(bool, block.params.items.len);
73067303 for (block.params.items) |param, i| {
7307 const param_src = LazySrcLoc.nodeOffset(src_node_offset); // TODO better soruce location
73087304 param_types[i] = param.ty;
7309 const requires_comptime = try sema.typeRequiresComptime(block, param_src, param.ty);
7310 comptime_params[i] = param.is_comptime or requires_comptime;
7311 is_generic = is_generic or comptime_params[i] or param.ty.tag() == .generic_poison;
7312 if (is_extern and is_generic) {
7313 // TODO add note: function is generic because of this parameter
7314 return sema.fail(block, param_src, "extern function cannot be generic", .{});
7315 }
7316 if (!param.ty.isValidParamType()) {
7317 const opaque_str = if (param.ty.zigTypeTag() == .Opaque) "opaque " else "";
7318 const msg = msg: {
7319 const msg = try sema.errMsg(block, param_src, "parameter of {s}type '{}' not allowed", .{
7320 opaque_str, param.ty.fmt(sema.mod),
7321 });
7322 errdefer msg.destroy(sema.gpa);
7323
7324 try sema.addDeclaredHereNote(msg, param.ty);
7325 break :msg msg;
7326 };
7327 return sema.failWithOwnedErrorMsg(block, msg);
7328 }
7329 if (!Type.fnCallingConventionAllowsZigTypes(cc_workaround) and !(try sema.validateExternType(param.ty, .param_ty))) {
7330 const msg = msg: {
7331 const msg = try sema.errMsg(block, param_src, "parameter of type '{}' not allowed in function with calling convention '{s}'", .{
7332 param.ty.fmt(sema.mod), @tagName(cc_workaround),
7333 });
7334 errdefer msg.destroy(sema.gpa);
7335
7336 const src_decl = sema.mod.declPtr(block.src_decl);
7337 try sema.explainWhyTypeIsNotExtern(block, param_src, msg, param_src.toSrcLoc(src_decl), param.ty, .param_ty);
7338
7339 try sema.addDeclaredHereNote(msg, param.ty);
7340 break :msg msg;
7341 };
7342 return sema.failWithOwnedErrorMsg(block, msg);
7343 }
7344 if (requires_comptime and !param.is_comptime) {
7345 const msg = msg: {
7346 const msg = try sema.errMsg(block, param_src, "parametter of type '{}' must be declared comptime", .{
7347 param.ty.fmt(sema.mod),
7348 });
7349 errdefer msg.destroy(sema.gpa);
7350
7351 try sema.addDeclaredHereNote(msg, param.ty);
7352 break :msg msg;
7353 };
7354 return sema.failWithOwnedErrorMsg(block, msg);
7355 }
7305 sema.analyzeParameter(
7306 block,
7307 fn_src,
7308 .unneeded,
7309 param,
7310 comptime_params,
7311 i,
7312 &is_generic,
7313 is_extern,
7314 cc_workaround,
7315 ) catch |err| switch (err) {
7316 error.NeededSourceLocation => {
7317 const decl = sema.mod.declPtr(block.src_decl);
7318 try sema.analyzeParameter(
7319 block,
7320 fn_src,
7321 Module.paramSrc(src_node_offset, sema.gpa, decl, i),
7322 param,
7323 comptime_params,
7324 i,
7325 &is_generic,
7326 is_extern,
7327 cc_workaround,
7328 );
7329 return error.AnalysisFail;
7330 },
7331 else => |e| return e,
7332 };
73567333 }
73577334
73587335 const ret_poison = if (!is_generic) rp: {
......@@ -7542,6 +7519,79 @@ fn funcCommon(
75427519 return sema.addConstant(fn_ty, Value.initPayload(&fn_payload.base));
75437520}
75447521
7522fn analyzeParameter(
7523 sema: *Sema,
7524 block: *Block,
7525 func_src: LazySrcLoc,
7526 param_src: LazySrcLoc,
7527 param: Block.Param,
7528 comptime_params: []bool,
7529 i: usize,
7530 is_generic: *bool,
7531 is_extern: bool,
7532 cc: std.builtin.CallingConvention,
7533) !void {
7534 const requires_comptime = try sema.typeRequiresComptime(block, param_src, param.ty);
7535 comptime_params[i] = param.is_comptime or requires_comptime;
7536 const this_generic = comptime_params[i] or param.ty.tag() == .generic_poison;
7537 is_generic.* = is_generic.* or this_generic;
7538 if (is_extern and this_generic) {
7539 // TODO this check should exist somewhere for notes.
7540 if (param_src == .unneeded) return error.NeededSourceLocation;
7541 const msg = msg: {
7542 const msg = try sema.errMsg(block, func_src, "extern function cannot be generic", .{});
7543 errdefer msg.destroy(sema.gpa);
7544
7545 try sema.errNote(block, param_src, msg, "function is generic because of this parameter", .{});
7546 break :msg msg;
7547 };
7548 return sema.failWithOwnedErrorMsg(block, msg);
7549 }
7550 if (this_generic and !Type.fnCallingConventionAllowsZigTypes(cc)) {
7551 return sema.fail(block, param_src, "generic parameters not allowed in function with calling convention '{s}'", .{@tagName(cc)});
7552 }
7553 if (!param.ty.isValidParamType()) {
7554 const opaque_str = if (param.ty.zigTypeTag() == .Opaque) "opaque " else "";
7555 const msg = msg: {
7556 const msg = try sema.errMsg(block, param_src, "parameter of {s}type '{}' not allowed", .{
7557 opaque_str, param.ty.fmt(sema.mod),
7558 });
7559 errdefer msg.destroy(sema.gpa);
7560
7561 try sema.addDeclaredHereNote(msg, param.ty);
7562 break :msg msg;
7563 };
7564 return sema.failWithOwnedErrorMsg(block, msg);
7565 }
7566 if (!Type.fnCallingConventionAllowsZigTypes(cc) and !(try sema.validateExternType(param.ty, .param_ty))) {
7567 const msg = msg: {
7568 const msg = try sema.errMsg(block, param_src, "parameter of type '{}' not allowed in function with calling convention '{s}'", .{
7569 param.ty.fmt(sema.mod), @tagName(cc),
7570 });
7571 errdefer msg.destroy(sema.gpa);
7572
7573 const src_decl = sema.mod.declPtr(block.src_decl);
7574 try sema.explainWhyTypeIsNotExtern(block, param_src, msg, param_src.toSrcLoc(src_decl), param.ty, .param_ty);
7575
7576 try sema.addDeclaredHereNote(msg, param.ty);
7577 break :msg msg;
7578 };
7579 return sema.failWithOwnedErrorMsg(block, msg);
7580 }
7581 if (requires_comptime and !param.is_comptime) {
7582 const msg = msg: {
7583 const msg = try sema.errMsg(block, param_src, "parametter of type '{}' must be declared comptime", .{
7584 param.ty.fmt(sema.mod),
7585 });
7586 errdefer msg.destroy(sema.gpa);
7587
7588 try sema.addDeclaredHereNote(msg, param.ty);
7589 break :msg msg;
7590 };
7591 return sema.failWithOwnedErrorMsg(block, msg);
7592 }
7593}
7594
75457595fn zirParam(
75467596 sema: *Sema,
75477597 block: *Block,
......@@ -18570,9 +18620,9 @@ fn explainWhyTypeIsNotExtern(
1857018620 .Union => try mod.errNoteNonLazy(src_loc, msg, "only unions with packed or extern layout are extern compatible", .{}),
1857118621 .Array => {
1857218622 if (position == .ret_ty) {
18573 try mod.errNoteNonLazy(src_loc, msg, "arrays are not allowed as a return type", .{});
18623 return mod.errNoteNonLazy(src_loc, msg, "arrays are not allowed as a return type", .{});
1857418624 } else if (position == .param_ty) {
18575 try mod.errNoteNonLazy(src_loc, msg, "arrays are not allowed as a parameter type", .{});
18625 return mod.errNoteNonLazy(src_loc, msg, "arrays are not allowed as a parameter type", .{});
1857618626 }
1857718627 try sema.explainWhyTypeIsNotExtern(block, src, msg, src_loc, ty.elemType2(), position);
1857818628 },
test/cases/compile_errors/array_in_c_exported_function.zig created+16
......@@ -0,0 +1,16 @@
1export fn zig_array(x: [10]u8) void {
2 try std.testing.expect(std.mem.eql(u8, &x, "1234567890"));
3}
4const std = @import("std");
5export fn zig_return_array() [10]u8 {
6 return "1234567890".*;
7}
8
9// error
10// backend=stage2
11// target=native
12//
13// :1:21: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'
14// :1:21: note: arrays are not allowed as a parameter type
15// :5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'
16// :5:30: note: arrays are not allowed as a return type
test/cases/compile_errors/export_function_with_comptime_parameter.zig created+9
......@@ -0,0 +1,9 @@
1export fn foo(comptime x: anytype, y: i32) i32{
2 return x + y;
3}
4
5// error
6// backend=stage2
7// target=native
8//
9// :1:15: error: generic parameters not allowed in function with calling convention 'C'
test/cases/compile_errors/export_generic_function.zig created+10
......@@ -0,0 +1,10 @@
1export fn foo(num: anytype) i32 {
2 _ = num;
3 return 0;
4}
5
6// error
7// backend=stage2
8// target=native
9//
10// :1:15: error: generic parameters not allowed in function with calling convention 'C'
test/cases/compile_errors/extern_function_with_comptime_parameter.zig created+20
......@@ -0,0 +1,20 @@
1extern fn foo(comptime x: i32, y: i32) i32;
2fn f() i32 {
3 return foo(1, 2);
4}
5pub extern fn entry1(b: u32, comptime a: [2]u8, c: i32) void;
6pub extern fn entry2(b: u32, noalias a: anytype, i43) void;
7comptime { _ = f; }
8comptime { _ = entry1; }
9comptime { _ = entry2; }
10
11// error
12// backend=stage2
13// target=native
14//
15// :5:12: error: extern function cannot be generic
16// :5:30: note: function is generic because of this parameter
17// :6:12: error: extern function cannot be generic
18// :6:30: note: function is generic because of this parameter
19// :1:8: error: extern function cannot be generic
20// :1:15: note: function is generic because of this parameter
test/cases/compile_errors/function_parameter_is_opaque.zig+5-4
......@@ -23,8 +23,9 @@ export fn entry4() void {
2323// backend=stage2
2424// target=native
2525//
26// :3:24: error: parameter of opaque type 'tmp.FooType' not allowed
26// :3:28: error: parameter of opaque type 'tmp.FooType' not allowed
2727// :1:17: note: opaque declared here
28// :8:24: error: parameter of type '@TypeOf(null)' not allowed
29// :12:1: error: parameter of opaque type 'tmp.FooType' not allowed
30// :17:1: error: parameter of type '@TypeOf(null)' not allowed
28// :8:28: error: parameter of type '@TypeOf(null)' not allowed
29// :12:8: error: parameter of opaque type 'tmp.FooType' not allowed
30// :1:17: note: opaque declared here
31// :17:8: error: parameter of type '@TypeOf(null)' not allowed
test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig+3-3
......@@ -5,7 +5,7 @@ export fn entry(foo: Foo) void { _ = foo; }
55// backend=stage2
66// target=native
77//
8// :2:8: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
9// :2:8: note: enum tag type 'u2' is not extern compatible
10// :2:8: note: only integers with power of two bits are extern compatible
8// :2:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
9// :2:17: note: enum tag type 'u2' is not extern compatible
10// :2:17: note: only integers with power of two bits are extern compatible
1111// :1:13: note: enum declared here
test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig+2-2
......@@ -9,6 +9,6 @@ export fn entry(foo: Foo) void { _ = foo; }
99// backend=stage2
1010// target=native
1111//
12// :6:8: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
13// :6:8: note: only structs with packed or extern layout are extern compatible
12// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
13// :6:17: note: only structs with packed or extern layout are extern compatible
1414// :1:13: note: struct declared here
test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig+2-2
......@@ -9,6 +9,6 @@ export fn entry(foo: Foo) void { _ = foo; }
99// backend=stage2
1010// target=native
1111//
12// :6:8: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
13// :6:8: note: only unions with packed or extern layout are extern compatible
12// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
13// :6:17: note: only unions with packed or extern layout are extern compatible
1414// :1:13: note: union declared here
test/cases/compile_errors/stage1/obj/array_in_c_exported_function.zig deleted-14
......@@ -1,14 +0,0 @@
1export fn zig_array(x: [10]u8) void {
2 try std.testing.expect(std.mem.eql(u8, &x, "1234567890"));
3}
4const std = @import("std");
5export fn zig_return_array() [10]u8 {
6 return "1234567890".*;
7}
8
9// error
10// backend=stage1
11// target=native
12//
13// tmp.zig:1:24: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'
14// tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'
test/cases/compile_errors/stage1/obj/export_function_with_comptime_parameter.zig deleted-9
......@@ -1,9 +0,0 @@
1export fn foo(comptime x: i32, y: i32) i32{
2 return x + y;
3}
4
5// error
6// backend=stage1
7// target=native
8//
9// tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'
test/cases/compile_errors/stage1/obj/export_generic_function.zig deleted-10
......@@ -1,10 +0,0 @@
1export fn foo(num: anytype) i32 {
2 _ = num;
3 return 0;
4}
5
6// error
7// backend=stage1
8// target=native
9//
10// tmp.zig:1:15: error: parameter of type 'anytype' not allowed in function with calling convention 'C'
test/cases/compile_errors/stage1/obj/extern_function_with_comptime_parameter.zig deleted-11
......@@ -1,11 +0,0 @@
1extern fn foo(comptime x: i32, y: i32) i32;
2fn f() i32 {
3 return foo(1, 2);
4}
5export fn entry() usize { return @sizeOf(@TypeOf(f)); }
6
7// error
8// backend=stage1
9// target=native
10//
11// tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'