authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-07-26 11:26:35-07:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-07-26 11:26:35-07:00
log0ffcf19e3d19ddd8c5f89d6ac8ff5a1d77666279
tree9ff618d76c1731de0cfaaa921c9f701607e8c24e
parenta0d3a87ce15a9f68047dc900109f5b76184d046f
parenta463dc7d6c3bb560903d11cb9e34668e89c374d6
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #12237 from Vexu/stage2-compile-errors

Stage2 improve errors for builtin function options structs

13 files changed, 381 insertions(+), 148 deletions(-)

lib/std/zig/Ast.zig+8
......@@ -297,6 +297,12 @@ pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void {
297297 .unattached_doc_comment => {
298298 return stream.writeAll("unattached documentation comment");
299299 },
300 .test_doc_comment => {
301 return stream.writeAll("documentation comments cannot be attached to tests");
302 },
303 .comptime_doc_comment => {
304 return stream.writeAll("documentation comments cannot be attached to comptime blocks");
305 },
300306 .varargs_nonfinal => {
301307 return stream.writeAll("function prototype has parameter after varargs");
302308 },
......@@ -2539,6 +2545,8 @@ pub const Error = struct {
25392545 invalid_bit_range,
25402546 same_line_doc_comment,
25412547 unattached_doc_comment,
2548 test_doc_comment,
2549 comptime_doc_comment,
25422550 varargs_nonfinal,
25432551 expected_continue_expr,
25442552 expected_semi_after_decl,
lib/std/zig/parse.zig+6
......@@ -259,6 +259,9 @@ const Parser = struct {
259259
260260 switch (p.token_tags[p.tok_i]) {
261261 .keyword_test => {
262 if (doc_comment) |some| {
263 try p.warnMsg(.{ .tag = .test_doc_comment, .token = some });
264 }
262265 const test_decl_node = try p.expectTestDeclRecoverable();
263266 if (test_decl_node != 0) {
264267 if (field_state == .seen) {
......@@ -317,6 +320,9 @@ const Parser = struct {
317320 }
318321 },
319322 .l_brace => {
323 if (doc_comment) |some| {
324 try p.warnMsg(.{ .tag = .test_doc_comment, .token = some });
325 }
320326 const comptime_token = p.nextToken();
321327 const block = p.parseBlock() catch |err| switch (err) {
322328 error.OutOfMemory => return error.OutOfMemory,
lib/std/zig/parser_test.zig-12
......@@ -184,15 +184,6 @@ test "zig fmt: file ends in comment after var decl" {
184184 );
185185}
186186
187test "zig fmt: doc comments on test" {
188 try testCanonical(
189 \\/// hello
190 \\/// world
191 \\test "" {}
192 \\
193 );
194}
195
196187test "zig fmt: if statment" {
197188 try testCanonical(
198189 \\test "" {
......@@ -2700,9 +2691,6 @@ test "zig fmt: comments in statements" {
27002691
27012692test "zig fmt: comments before test decl" {
27022693 try testCanonical(
2703 \\/// top level doc comment
2704 \\test "hi" {}
2705 \\
27062694 \\// top level normal comment
27072695 \\test "hi" {}
27082696 \\
lib/std/zig/system/darwin.zig+1-1
......@@ -87,6 +87,6 @@ pub const DarwinSDK = struct {
8787 }
8888};
8989
90test "" {
90test {
9191 _ = macos;
9292}
src/AstGen.zig+37-1
......@@ -3497,6 +3497,12 @@ fn fnDecl(
34973497
34983498 const lib_name: u32 = if (fn_proto.lib_name) |lib_name_token| blk: {
34993499 const lib_name_str = try astgen.strLitAsString(lib_name_token);
3500 const lib_name_slice = astgen.string_bytes.items[lib_name_str.index..][0..lib_name_str.len];
3501 if (mem.indexOfScalar(u8, lib_name_slice, 0) != null) {
3502 return astgen.failTok(lib_name_token, "library name cannot contain null bytes", .{});
3503 } else if (lib_name_str.len == 0) {
3504 return astgen.failTok(lib_name_token, "library name cannot be empty", .{});
3505 }
35003506 break :blk lib_name_str.index;
35013507 } else 0;
35023508
......@@ -3750,6 +3756,12 @@ fn globalVarDecl(
37503756
37513757 const lib_name: u32 = if (var_decl.lib_name) |lib_name_token| blk: {
37523758 const lib_name_str = try astgen.strLitAsString(lib_name_token);
3759 const lib_name_slice = astgen.string_bytes.items[lib_name_str.index..][0..lib_name_str.len];
3760 if (mem.indexOfScalar(u8, lib_name_slice, 0) != null) {
3761 return astgen.failTok(lib_name_token, "library name cannot contain null bytes", .{});
3762 } else if (lib_name_str.len == 0) {
3763 return astgen.failTok(lib_name_token, "library name cannot be empty", .{});
3764 }
37533765 break :blk lib_name_str.index;
37543766 } else 0;
37553767
......@@ -7239,6 +7251,12 @@ fn builtinCall(
72397251 }
72407252 const str_lit_token = main_tokens[operand_node];
72417253 const str = try astgen.strLitAsString(str_lit_token);
7254 const str_slice = astgen.string_bytes.items[str.index..][0..str.len];
7255 if (mem.indexOfScalar(u8, str_slice, 0) != null) {
7256 return astgen.failTok(str_lit_token, "import path cannot contain null bytes", .{});
7257 } else if (str.len == 0) {
7258 return astgen.failTok(str_lit_token, "import path cannot be empty", .{});
7259 }
72427260 const result = try gz.addStrTok(.import, str.index, str_lit_token);
72437261 const gop = try astgen.imports.getOrPut(astgen.gpa, str.index);
72447262 if (!gop.found_existing) {
......@@ -9260,6 +9278,11 @@ fn identifierTokenString(astgen: *AstGen, token: Ast.TokenIndex) InnerError![]co
92609278 var buf: ArrayListUnmanaged(u8) = .{};
92619279 defer buf.deinit(astgen.gpa);
92629280 try astgen.parseStrLit(token, &buf, ident_name, 1);
9281 if (mem.indexOfScalar(u8, buf.items, 0) != null) {
9282 return astgen.failTok(token, "identifier cannot contain null bytes", .{});
9283 } else if (buf.items.len == 0) {
9284 return astgen.failTok(token, "identifier cannot be empty", .{});
9285 }
92639286 const duped = try astgen.arena.dupe(u8, buf.items);
92649287 return duped;
92659288}
......@@ -9279,7 +9302,14 @@ fn appendIdentStr(
92799302 if (!mem.startsWith(u8, ident_name, "@")) {
92809303 return buf.appendSlice(astgen.gpa, ident_name);
92819304 } else {
9282 return astgen.parseStrLit(token, buf, ident_name, 1);
9305 const start = buf.items.len;
9306 try astgen.parseStrLit(token, buf, ident_name, 1);
9307 const slice = buf.items[start..];
9308 if (mem.indexOfScalar(u8, slice, 0) != null) {
9309 return astgen.failTok(token, "identifier cannot contain null bytes", .{});
9310 } else if (slice.len == 0) {
9311 return astgen.failTok(token, "identifier cannot be empty", .{});
9312 }
92839313 }
92849314}
92859315
......@@ -9723,6 +9753,12 @@ fn testNameString(astgen: *AstGen, str_lit_token: Ast.TokenIndex) !u32 {
97239753 const token_bytes = astgen.tree.tokenSlice(str_lit_token);
97249754 try string_bytes.append(gpa, 0); // Indicates this is a test.
97259755 try astgen.parseStrLit(str_lit_token, string_bytes, token_bytes, 0);
9756 const slice = string_bytes.items[str_index + 1 ..];
9757 if (mem.indexOfScalar(u8, slice, 0) != null) {
9758 return astgen.failTok(str_lit_token, "test name cannot contain null bytes", .{});
9759 } else if (slice.len == 0) {
9760 return astgen.failTok(str_lit_token, "empty test name must be omitted", .{});
9761 }
97269762 try string_bytes.append(gpa, 0);
97279763 return str_index;
97289764}
src/Module.zig+57-3
......@@ -5939,10 +5939,11 @@ pub fn argSrc(
59395939 call_node_offset: i32,
59405940 gpa: Allocator,
59415941 decl: *Decl,
5942 arg_i: usize,
5942 start_arg_i: usize,
59435943 bound_arg_src: ?LazySrcLoc,
59445944) LazySrcLoc {
5945 if (arg_i == 0 and bound_arg_src != null) return bound_arg_src.?;
5945 if (start_arg_i == 0 and bound_arg_src != null) return bound_arg_src.?;
5946 const arg_i = start_arg_i - @boolToInt(bound_arg_src != null);
59465947 @setCold(true);
59475948 const tree = decl.getFileScope().getTree(gpa) catch |err| {
59485949 // In this case we emit a warning + a less precise source location.
......@@ -5957,6 +5958,12 @@ pub fn argSrc(
59575958 const full = switch (node_tags[node]) {
59585959 .call_one, .call_one_comma, .async_call_one, .async_call_one_comma => tree.callOne(&args, node),
59595960 .call, .call_comma, .async_call, .async_call_comma => tree.callFull(node),
5961 .builtin_call => {
5962 const node_datas = tree.nodes.items(.data);
5963 const call_args_node = tree.extra_data[node_datas[node].rhs - 1];
5964 const call_args_offset = decl.nodeIndexToRelative(call_args_node);
5965 return initSrc(call_args_offset, gpa, decl, arg_i);
5966 },
59605967 else => unreachable,
59615968 };
59625969 return LazySrcLoc.nodeOffset(decl.nodeIndexToRelative(full.ast.params[arg_i]));
......@@ -5989,7 +5996,7 @@ pub fn initSrc(
59895996 .struct_init_dot_two, .struct_init_dot_two_comma => tree.structInitDotTwo(&buf, node).ast.fields,
59905997 .struct_init_dot, .struct_init_dot_comma => tree.structInitDot(node).ast.fields,
59915998 .struct_init, .struct_init_comma => tree.structInit(node).ast.fields,
5992 else => unreachable,
5999 else => return LazySrcLoc.nodeOffset(init_node_offset),
59936000 };
59946001 switch (node_tags[node]) {
59956002 .array_init_one,
......@@ -6014,6 +6021,53 @@ pub fn initSrc(
60146021 }
60156022}
60166023
6024pub fn optionsSrc(gpa: Allocator, decl: *Decl, base_src: LazySrcLoc, wanted: []const u8) LazySrcLoc {
6025 @setCold(true);
6026 const tree = decl.getFileScope().getTree(gpa) catch |err| {
6027 // In this case we emit a warning + a less precise source location.
6028 log.warn("unable to load {s}: {s}", .{
6029 decl.getFileScope().sub_file_path, @errorName(err),
6030 });
6031 return LazySrcLoc.nodeOffset(0);
6032 };
6033
6034 const o_i: struct { off: i32, i: u8 } = switch (base_src) {
6035 .node_offset_builtin_call_arg0 => |n| .{ .off = n, .i = 0 },
6036 .node_offset_builtin_call_arg1 => |n| .{ .off = n, .i = 1 },
6037 else => unreachable,
6038 };
6039
6040 const node = decl.relativeToNodeIndex(o_i.off);
6041 const node_datas = tree.nodes.items(.data);
6042 const node_tags = tree.nodes.items(.tag);
6043 const arg_node = switch (node_tags[node]) {
6044 .builtin_call_two, .builtin_call_two_comma => switch (o_i.i) {
6045 0 => node_datas[node].lhs,
6046 1 => node_datas[node].rhs,
6047 else => unreachable,
6048 },
6049 .builtin_call, .builtin_call_comma => tree.extra_data[node_datas[node].lhs + o_i.i],
6050 else => unreachable,
6051 };
6052 var buf: [2]std.zig.Ast.Node.Index = undefined;
6053 const init_nodes = switch (node_tags[arg_node]) {
6054 .struct_init_one, .struct_init_one_comma => tree.structInitOne(buf[0..1], arg_node).ast.fields,
6055 .struct_init_dot_two, .struct_init_dot_two_comma => tree.structInitDotTwo(&buf, arg_node).ast.fields,
6056 .struct_init_dot, .struct_init_dot_comma => tree.structInitDot(arg_node).ast.fields,
6057 .struct_init, .struct_init_comma => tree.structInit(arg_node).ast.fields,
6058 else => return base_src,
6059 };
6060 for (init_nodes) |init_node| {
6061 // . IDENTIFIER = init_node
6062 const name_token = tree.firstToken(init_node) - 2;
6063 const name = tree.tokenSlice(name_token);
6064 if (std.mem.eql(u8, name, wanted)) {
6065 return LazySrcLoc{ .node_offset_initializer = decl.nodeIndexToRelative(init_node) };
6066 }
6067 }
6068 return base_src;
6069}
6070
60176071/// Called from `performAllTheWork`, after all AstGen workers have finished,
60186072/// and before the main semantic analysis loop begins.
60196073pub fn processOutdatedAndDeletedDecls(mod: *Module) !void {
src/Sema.zig+219-126
......@@ -4909,7 +4909,13 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
49094909 return sema.fail(block, src, "TODO: implement exporting with field access", .{});
49104910 }
49114911 const decl_index = try sema.lookupIdentifier(block, operand_src, decl_name);
4912 const options = try sema.resolveExportOptions(block, options_src, extra.options);
4912 const options = sema.resolveExportOptions(block, .unneeded, extra.options) catch |err| switch (err) {
4913 error.NeededSourceLocation => {
4914 _ = try sema.resolveExportOptions(block, options_src, extra.options);
4915 return error.AnalysisFail;
4916 },
4917 else => |e| return e,
4918 };
49134919 try sema.analyzeExport(block, src, options, decl_index);
49144920}
49154921
......@@ -4923,7 +4929,13 @@ fn zirExportValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
49234929 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
49244930 const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
49254931 const operand = try sema.resolveInstConst(block, operand_src, extra.operand, "export target must be comptime known");
4926 const options = try sema.resolveExportOptions(block, options_src, extra.options);
4932 const options = sema.resolveExportOptions(block, .unneeded, extra.options) catch |err| switch (err) {
4933 error.NeededSourceLocation => {
4934 _ = try sema.resolveExportOptions(block, options_src, extra.options);
4935 return error.AnalysisFail;
4936 },
4937 else => |e| return e,
4938 };
49274939 const decl_index = switch (operand.val.tag()) {
49284940 .function => operand.val.castTag(.function).?.data.owner_decl,
49294941 else => return sema.fail(block, operand_src, "TODO implement exporting arbitrary Value objects", .{}), // TODO put this Value into an anonymous Decl and then export it.
......@@ -17029,6 +17041,11 @@ fn checkVectorizableBinaryOperands(
1702917041 }
1703017042}
1703117043
17044fn maybeOptionsSrc(sema: *Sema, block: *Block, base_src: LazySrcLoc, wanted: []const u8) LazySrcLoc {
17045 if (base_src == .unneeded) return .unneeded;
17046 return Module.optionsSrc(sema.gpa, sema.mod.declPtr(block.src_decl), base_src, wanted);
17047}
17048
1703217049fn resolveExportOptions(
1703317050 sema: *Sema,
1703417051 block: *Block,
......@@ -17039,34 +17056,39 @@ fn resolveExportOptions(
1703917056 const air_ref = try sema.resolveInst(zir_ref);
1704017057 const options = try sema.coerce(block, export_options_ty, air_ref, src);
1704117058
17042 const name_operand = try sema.fieldVal(block, src, options, "name", src);
17043 const name_val = try sema.resolveConstValue(block, src, name_operand, "name of exported value must be comptime known");
17059 const name_src = sema.maybeOptionsSrc(block, src, "name");
17060 const linkage_src = sema.maybeOptionsSrc(block, src, "linkage");
17061 const section_src = sema.maybeOptionsSrc(block, src, "section");
17062 const visibility_src = sema.maybeOptionsSrc(block, src, "visibility");
17063
17064 const name_operand = try sema.fieldVal(block, src, options, "name", name_src);
17065 const name_val = try sema.resolveConstValue(block, name_src, name_operand, "name of exported value must be comptime known");
1704417066 const name_ty = Type.initTag(.const_slice_u8);
1704517067 const name = try name_val.toAllocatedBytes(name_ty, sema.arena, sema.mod);
1704617068
17047 const linkage_operand = try sema.fieldVal(block, src, options, "linkage", src);
17048 const linkage_val = try sema.resolveConstValue(block, src, linkage_operand, "linkage of exported value must be comptime known");
17069 const linkage_operand = try sema.fieldVal(block, src, options, "linkage", linkage_src);
17070 const linkage_val = try sema.resolveConstValue(block, linkage_src, linkage_operand, "linkage of exported value must be comptime known");
1704917071 const linkage = linkage_val.toEnum(std.builtin.GlobalLinkage);
1705017072
17051 const section = try sema.fieldVal(block, src, options, "section", src);
17052 const section_val = try sema.resolveConstValue(block, src, section, "linksection of exported value must be comptime known");
17073 const section = try sema.fieldVal(block, src, options, "section", section_src);
17074 const section_val = try sema.resolveConstValue(block, section_src, section, "linksection of exported value must be comptime known");
1705317075
17054 const visibility_operand = try sema.fieldVal(block, src, options, "visibility", src);
17055 const visibility_val = try sema.resolveConstValue(block, src, visibility_operand, "visibility of exported value must be comptime known");
17076 const visibility_operand = try sema.fieldVal(block, src, options, "visibility", visibility_src);
17077 const visibility_val = try sema.resolveConstValue(block, visibility_src, visibility_operand, "visibility of exported value must be comptime known");
1705617078 const visibility = visibility_val.toEnum(std.builtin.SymbolVisibility);
1705717079
1705817080 if (name.len < 1) {
17059 return sema.fail(block, src, "exported symbol name cannot be empty", .{});
17081 return sema.fail(block, name_src, "exported symbol name cannot be empty", .{});
1706017082 }
1706117083
1706217084 if (visibility != .default and linkage == .Internal) {
17063 return sema.fail(block, src, "symbol '{s}' exported with internal linkage has non-default visibility {s}", .{
17085 return sema.fail(block, visibility_src, "symbol '{s}' exported with internal linkage has non-default visibility {s}", .{
1706417086 name, @tagName(visibility),
1706517087 });
1706617088 }
1706717089
1706817090 if (!section_val.isNull()) {
17069 return sema.fail(block, src, "TODO: implement exporting with linksection", .{});
17091 return sema.fail(block, section_src, "TODO: implement exporting with linksection", .{});
1707017092 }
1707117093
1707217094 return std.builtin.ExportOptions{
......@@ -17805,80 +17827,113 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1780517827 });
1780617828}
1780717829
17808fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
17809 const tracy = trace(@src());
17810 defer tracy.end();
17811
17812 const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
17813 const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
17814 const func_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
17815 const args_src: LazySrcLoc = .{ .node_offset_builtin_call_arg2 = inst_data.src_node };
17816 const call_src = inst_data.src();
17817
17818 const extra = sema.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data;
17819 var func = try sema.resolveInst(extra.callee);
17820 const options = try sema.resolveInst(extra.options);
17821 const args = try sema.resolveInst(extra.args);
17822
17823 const wanted_modifier: std.builtin.CallOptions.Modifier = modifier: {
17824 const call_options_ty = try sema.getBuiltinType(block, options_src, "CallOptions");
17825 const coerced_options = try sema.coerce(block, call_options_ty, options, options_src);
17830fn resolveCallOptions(
17831 sema: *Sema,
17832 block: *Block,
17833 src: LazySrcLoc,
17834 zir_ref: Zir.Inst.Ref,
17835 is_comptime: bool,
17836 is_nosuspend: bool,
17837 func: Air.Inst.Ref,
17838 func_src: LazySrcLoc,
17839) CompileError!std.builtin.CallOptions.Modifier {
17840 const call_options_ty = try sema.getBuiltinType(block, src, "CallOptions");
17841 const air_ref = try sema.resolveInst(zir_ref);
17842 const options = try sema.coerce(block, call_options_ty, air_ref, src);
1782617843
17827 const modifier = try sema.fieldVal(block, options_src, coerced_options, "modifier", options_src);
17828 const modifier_val = try sema.resolveConstValue(block, options_src, modifier, "call modifier must be comptime known");
17844 const modifier_src = sema.maybeOptionsSrc(block, src, "modifier");
17845 const stack_src = sema.maybeOptionsSrc(block, src, "stack");
1782917846
17830 const stack = try sema.fieldVal(block, options_src, coerced_options, "stack", options_src);
17831 const stack_val = try sema.resolveConstValue(block, options_src, stack, "call stack value must be comptime known");
17847 const modifier = try sema.fieldVal(block, src, options, "modifier", modifier_src);
17848 const modifier_val = try sema.resolveConstValue(block, modifier_src, modifier, "call modifier must be comptime known");
17849 const wanted_modifier = modifier_val.toEnum(std.builtin.CallOptions.Modifier);
1783217850
17833 if (!stack_val.isNull()) {
17834 return sema.fail(block, options_src, "TODO: implement @call with stack", .{});
17835 }
17836 break :modifier modifier_val.toEnum(std.builtin.CallOptions.Modifier);
17837 };
17851 const stack = try sema.fieldVal(block, src, options, "stack", stack_src);
17852 const stack_val = try sema.resolveConstValue(block, stack_src, stack, "call stack value must be comptime known");
1783817853
17839 const is_comptime = extra.flags.is_comptime or block.is_comptime;
17854 if (!stack_val.isNull()) {
17855 return sema.fail(block, stack_src, "TODO: implement @call with stack", .{});
17856 }
1784017857
17841 const modifier: std.builtin.CallOptions.Modifier = switch (wanted_modifier) {
17858 switch (wanted_modifier) {
1784217859 // These can be upgraded to comptime or nosuspend calls.
17843 .auto, .never_tail, .no_async => m: {
17860 .auto, .never_tail, .no_async => {
1784417861 if (is_comptime) {
1784517862 if (wanted_modifier == .never_tail) {
17846 return sema.fail(block, options_src, "unable to perform 'never_tail' call at compile-time", .{});
17863 return sema.fail(block, modifier_src, "unable to perform 'never_tail' call at compile-time", .{});
1784717864 }
17848 break :m .compile_time;
17865 return .compile_time;
1784917866 }
17850 if (extra.flags.is_nosuspend) {
17851 break :m .no_async;
17867 if (is_nosuspend) {
17868 return .no_async;
1785217869 }
17853 break :m wanted_modifier;
17870 return wanted_modifier;
1785417871 },
1785517872 // These can be upgraded to comptime. nosuspend bit can be safely ignored.
17856 .always_tail, .always_inline, .compile_time => m: {
17873 .always_tail, .always_inline, .compile_time => {
1785717874 _ = (try sema.resolveDefinedValue(block, func_src, func)) orelse {
1785817875 return sema.fail(block, func_src, "modifier '{s}' requires a comptime-known function", .{@tagName(wanted_modifier)});
1785917876 };
1786017877
1786117878 if (is_comptime) {
17862 break :m .compile_time;
17879 return .compile_time;
1786317880 }
17864 break :m wanted_modifier;
17881 return wanted_modifier;
1786517882 },
17866 .async_kw => m: {
17867 if (extra.flags.is_nosuspend) {
17868 return sema.fail(block, options_src, "modifier 'async_kw' cannot be used inside nosuspend block", .{});
17883 .async_kw => {
17884 if (is_nosuspend) {
17885 return sema.fail(block, modifier_src, "modifier 'async_kw' cannot be used inside nosuspend block", .{});
1786917886 }
1787017887 if (is_comptime) {
17871 return sema.fail(block, options_src, "modifier 'async_kw' cannot be used in combination with comptime function call", .{});
17888 return sema.fail(block, modifier_src, "modifier 'async_kw' cannot be used in combination with comptime function call", .{});
1787217889 }
17873 break :m wanted_modifier;
17890 return wanted_modifier;
1787417891 },
17875 .never_inline => m: {
17892 .never_inline => {
1787617893 if (is_comptime) {
17877 return sema.fail(block, options_src, "unable to perform 'never_inline' call at compile-time", .{});
17894 return sema.fail(block, modifier_src, "unable to perform 'never_inline' call at compile-time", .{});
1787817895 }
17879 break :m wanted_modifier;
17896 return wanted_modifier;
1788017897 },
17898 }
17899}
17900
17901fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
17902 const tracy = trace(@src());
17903 defer tracy.end();
17904
17905 const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
17906 const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
17907 const func_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
17908 const args_src: LazySrcLoc = .{ .node_offset_builtin_call_arg2 = inst_data.src_node };
17909 const call_src = inst_data.src();
17910
17911 const extra = sema.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data;
17912 var func = try sema.resolveInst(extra.callee);
17913 const modifier = sema.resolveCallOptions(
17914 block,
17915 .unneeded,
17916 extra.options,
17917 extra.flags.is_comptime,
17918 extra.flags.is_nosuspend,
17919 func,
17920 func_src,
17921 ) catch |err| switch (err) {
17922 error.NeededSourceLocation => {
17923 _ = try sema.resolveCallOptions(
17924 block,
17925 options_src,
17926 extra.options,
17927 extra.flags.is_comptime,
17928 extra.flags.is_nosuspend,
17929 func,
17930 func_src,
17931 );
17932 return error.AnalysisFail;
17933 },
17934 else => |e| return e,
1788117935 };
17936 const args = try sema.resolveInst(extra.args);
1788217937
1788317938 const args_ty = sema.typeOf(args);
1788417939 if (!args_ty.isTuple() and args_ty.tag() != .empty_struct_literal) {
......@@ -18579,6 +18634,36 @@ fn zirWasmMemoryGrow(
1857918634 });
1858018635}
1858118636
18637fn resolvePrefetchOptions(
18638 sema: *Sema,
18639 block: *Block,
18640 src: LazySrcLoc,
18641 zir_ref: Zir.Inst.Ref,
18642) CompileError!std.builtin.PrefetchOptions {
18643 const options_ty = try sema.getBuiltinType(block, src, "PrefetchOptions");
18644 const options = try sema.coerce(block, options_ty, try sema.resolveInst(zir_ref), src);
18645 const target = sema.mod.getTarget();
18646
18647 const rw_src = sema.maybeOptionsSrc(block, src, "rw");
18648 const locality_src = sema.maybeOptionsSrc(block, src, "locality");
18649 const cache_src = sema.maybeOptionsSrc(block, src, "cache");
18650
18651 const rw = try sema.fieldVal(block, src, options, "rw", rw_src);
18652 const rw_val = try sema.resolveConstValue(block, rw_src, rw, "prefetch read/write must be comptime known");
18653
18654 const locality = try sema.fieldVal(block, src, options, "locality", locality_src);
18655 const locality_val = try sema.resolveConstValue(block, locality_src, locality, "prefetch locality must be comptime known");
18656
18657 const cache = try sema.fieldVal(block, src, options, "cache", cache_src);
18658 const cache_val = try sema.resolveConstValue(block, cache_src, cache, "prefetch cache must be comptime known");
18659
18660 return std.builtin.PrefetchOptions{
18661 .rw = rw_val.toEnum(std.builtin.PrefetchOptions.Rw),
18662 .locality = @intCast(u2, locality_val.toUnsignedInt(target)),
18663 .cache = cache_val.toEnum(std.builtin.PrefetchOptions.Cache),
18664 };
18665}
18666
1858218667fn zirPrefetch(
1858318668 sema: *Sema,
1858418669 block: *Block,
......@@ -18587,32 +18672,25 @@ fn zirPrefetch(
1858718672 const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
1858818673 const ptr_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
1858918674 const opts_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = extra.node };
18590 const options_ty = try sema.getBuiltinType(block, opts_src, "PrefetchOptions");
1859118675 const ptr = try sema.resolveInst(extra.lhs);
1859218676 try sema.checkPtrOperand(block, ptr_src, sema.typeOf(ptr));
18593 const options = try sema.coerce(block, options_ty, try sema.resolveInst(extra.rhs), opts_src);
18594 const target = sema.mod.getTarget();
18595
18596 const rw = try sema.fieldVal(block, opts_src, options, "rw", opts_src);
18597 const rw_val = try sema.resolveConstValue(block, opts_src, rw, "prefetch read/write must be comptime known");
18598 const rw_tag = rw_val.toEnum(std.builtin.PrefetchOptions.Rw);
18599
18600 const locality = try sema.fieldVal(block, opts_src, options, "locality", opts_src);
18601 const locality_val = try sema.resolveConstValue(block, opts_src, locality, "prefetch locality must be comptime known");
18602 const locality_int = @intCast(u2, locality_val.toUnsignedInt(target));
1860318677
18604 const cache = try sema.fieldVal(block, opts_src, options, "cache", opts_src);
18605 const cache_val = try sema.resolveConstValue(block, opts_src, cache, "prefetch cache must be comptime known");
18606 const cache_tag = cache_val.toEnum(std.builtin.PrefetchOptions.Cache);
18678 const options = sema.resolvePrefetchOptions(block, .unneeded, extra.rhs) catch |err| switch (err) {
18679 error.NeededSourceLocation => {
18680 _ = try sema.resolvePrefetchOptions(block, opts_src, extra.rhs);
18681 return error.AnalysisFail;
18682 },
18683 else => |e| return e,
18684 };
1860718685
1860818686 if (!block.is_comptime) {
1860918687 _ = try block.addInst(.{
1861018688 .tag = .prefetch,
1861118689 .data = .{ .prefetch = .{
1861218690 .ptr = ptr,
18613 .rw = rw_tag,
18614 .locality = locality_int,
18615 .cache = cache_tag,
18691 .rw = options.rw,
18692 .locality = options.locality,
18693 .cache = options.cache,
1861618694 } },
1861718695 });
1861818696 }
......@@ -18620,71 +18698,93 @@ fn zirPrefetch(
1862018698 return Air.Inst.Ref.void_value;
1862118699}
1862218700
18623fn zirBuiltinExtern(
18701fn resolveExternOptions(
1862418702 sema: *Sema,
1862518703 block: *Block,
18626 extended: Zir.Inst.Extended.InstData,
18627) CompileError!Air.Inst.Ref {
18628 const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
18629 const src = LazySrcLoc.nodeOffset(extra.node);
18630 const ty_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
18631 const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = extra.node };
18632
18633 var ty = try sema.resolveType(block, ty_src, extra.lhs);
18634 const options_inst = try sema.resolveInst(extra.rhs);
18704 src: LazySrcLoc,
18705 zir_ref: Zir.Inst.Ref,
18706) CompileError!std.builtin.ExternOptions {
18707 const options_inst = try sema.resolveInst(zir_ref);
18708 const extern_options_ty = try sema.getBuiltinType(block, src, "ExternOptions");
18709 const options = try sema.coerce(block, extern_options_ty, options_inst, src);
1863518710 const mod = sema.mod;
1863618711
18637 const options = options: {
18638 const extern_options_ty = try sema.getBuiltinType(block, options_src, "ExternOptions");
18639 const options = try sema.coerce(block, extern_options_ty, options_inst, options_src);
18712 const name_src = sema.maybeOptionsSrc(block, src, "name");
18713 const library_src = sema.maybeOptionsSrc(block, src, "library");
18714 const linkage_src = sema.maybeOptionsSrc(block, src, "linkage");
18715 const thread_local_src = sema.maybeOptionsSrc(block, src, "thread_local");
1864018716
18641 const name = try sema.fieldVal(block, options_src, options, "name", options_src);
18642 const name_val = try sema.resolveConstValue(block, options_src, name, "name of the extern symbol must be comptime known");
18717 const name_ref = try sema.fieldVal(block, src, options, "name", name_src);
18718 const name_val = try sema.resolveConstValue(block, name_src, name_ref, "name of the extern symbol must be comptime known");
18719 const name = try name_val.toAllocatedBytes(Type.initTag(.const_slice_u8), sema.arena, mod);
1864318720
18644 const library_name_inst = try sema.fieldVal(block, options_src, options, "library_name", options_src);
18645 const library_name_val = try sema.resolveConstValue(block, options_src, library_name_inst, "library in which extern symbol is must be comptime known");
18721 const library_name_inst = try sema.fieldVal(block, src, options, "library_name", library_src);
18722 const library_name_val = try sema.resolveConstValue(block, library_src, library_name_inst, "library in which extern symbol is must be comptime known");
1864618723
18647 const linkage = try sema.fieldVal(block, options_src, options, "linkage", options_src);
18648 const linkage_val = try sema.resolveConstValue(block, options_src, linkage, "linkage of the extern symbol must be comptime known");
18724 const linkage_ref = try sema.fieldVal(block, src, options, "linkage", linkage_src);
18725 const linkage_val = try sema.resolveConstValue(block, linkage_src, linkage_ref, "linkage of the extern symbol must be comptime known");
18726 const linkage = linkage_val.toEnum(std.builtin.GlobalLinkage);
1864918727
18650 const is_thread_local = try sema.fieldVal(block, options_src, options, "is_thread_local", options_src);
18651 const is_thread_local_val = try sema.resolveConstValue(block, options_src, is_thread_local, "threadlocality of the extern symbol must be comptime known");
18728 const is_thread_local = try sema.fieldVal(block, src, options, "is_thread_local", thread_local_src);
18729 const is_thread_local_val = try sema.resolveConstValue(block, thread_local_src, is_thread_local, "threadlocality of the extern symbol must be comptime known");
1865218730
18653 var library_name: ?[]const u8 = null;
18654 if (!library_name_val.isNull()) {
18655 const payload = library_name_val.castTag(.opt_payload).?.data;
18656 library_name = try payload.toAllocatedBytes(Type.initTag(.const_slice_u8), sema.arena, mod);
18731 const library_name = if (!library_name_val.isNull()) blk: {
18732 const payload = library_name_val.castTag(.opt_payload).?.data;
18733 const library_name = try payload.toAllocatedBytes(Type.initTag(.const_slice_u8), sema.arena, mod);
18734 if (library_name.len == 0) {
18735 return sema.fail(block, library_src, "library name name cannot be empty", .{});
1865718736 }
18737 break :blk try sema.handleExternLibName(block, library_src, library_name);
18738 } else null;
1865818739
18659 break :options std.builtin.ExternOptions{
18660 .name = try name_val.toAllocatedBytes(Type.initTag(.const_slice_u8), sema.arena, mod),
18661 .library_name = library_name,
18662 .linkage = linkage_val.toEnum(std.builtin.GlobalLinkage),
18663 .is_thread_local = is_thread_local_val.toBool(),
18664 };
18665 };
18666
18667 if (!ty.isPtrAtRuntime()) {
18668 return sema.fail(block, options_src, "expected (optional) pointer", .{});
18740 if (name.len == 0) {
18741 return sema.fail(block, name_src, "extern symbol name cannot be empty", .{});
1866918742 }
1867018743
18671 if (options.name.len == 0) {
18672 return sema.fail(block, options_src, "extern symbol name cannot be empty", .{});
18744 if (linkage != .Weak and linkage != .Strong) {
18745 return sema.fail(block, linkage_src, "extern symbol must use strong or weak linkage", .{});
1867318746 }
1867418747
18675 if (options.linkage != .Weak and options.linkage != .Strong) {
18676 return sema.fail(block, options_src, "extern symbol must use strong or weak linkage", .{});
18748 return std.builtin.ExternOptions{
18749 .name = name,
18750 .library_name = library_name,
18751 .linkage = linkage,
18752 .is_thread_local = is_thread_local_val.toBool(),
18753 };
18754}
18755
18756fn zirBuiltinExtern(
18757 sema: *Sema,
18758 block: *Block,
18759 extended: Zir.Inst.Extended.InstData,
18760) CompileError!Air.Inst.Ref {
18761 const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
18762 const src = LazySrcLoc.nodeOffset(extra.node);
18763 const ty_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
18764 const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = extra.node };
18765
18766 var ty = try sema.resolveType(block, ty_src, extra.lhs);
18767 if (!ty.isPtrAtRuntime()) {
18768 return sema.fail(block, ty_src, "expected (optional) pointer", .{});
1867718769 }
1867818770
18771 const options = sema.resolveExternOptions(block, .unneeded, extra.rhs) catch |err| switch (err) {
18772 error.NeededSourceLocation => {
18773 _ = try sema.resolveExternOptions(block, options_src, extra.rhs);
18774 return error.AnalysisFail;
18775 },
18776 else => |e| return e,
18777 };
18778
1867918779 if (options.linkage == .Weak and !ty.ptrAllowsZero()) {
1868018780 ty = try Type.optional(sema.arena, ty);
1868118781 }
1868218782
1868318783 // TODO check duplicate extern
1868418784
18685 const new_decl_index = try mod.allocateNewDecl(sema.owner_decl.src_namespace, sema.owner_decl.src_node, null);
18686 errdefer mod.destroyDecl(new_decl_index);
18687 const new_decl = mod.declPtr(new_decl_index);
18785 const new_decl_index = try sema.mod.allocateNewDecl(sema.owner_decl.src_namespace, sema.owner_decl.src_node, null);
18786 errdefer sema.mod.destroyDecl(new_decl_index);
18787 const new_decl = sema.mod.declPtr(new_decl_index);
1868818788 new_decl.name = try sema.gpa.dupeZ(u8, options.name);
1868918789
1869018790 var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
......@@ -18704,13 +18804,6 @@ fn zirBuiltinExtern(
1870418804 .lib_name = null,
1870518805 };
1870618806
18707 if (options.library_name) |library_name| {
18708 if (library_name.len == 0) {
18709 return sema.fail(block, options_src, "library name name cannot be empty", .{});
18710 }
18711 new_var.lib_name = try sema.handleExternLibName(block, options_src, library_name);
18712 }
18713
1871418807 new_decl.src_line = sema.owner_decl.src_line;
1871518808 new_decl.ty = try ty.copy(new_decl_arena_allocator);
1871618809 new_decl.val = try Value.Tag.variable.create(new_decl_arena_allocator, new_var);
......@@ -18718,7 +18811,7 @@ fn zirBuiltinExtern(
1871818811 new_decl.@"linksection" = null;
1871918812 new_decl.has_tv = true;
1872018813 new_decl.analysis = .complete;
18721 new_decl.generation = mod.generation;
18814 new_decl.generation = sema.mod.generation;
1872218815
1872318816 const arena_state = try new_decl_arena_allocator.create(std.heap.ArenaAllocator.State);
1872418817 arena_state.* = new_decl_arena.state;
test/cases/compile_errors/bad_usage_of_call.zig+2-2
......@@ -28,8 +28,8 @@ fn baz2() void {}
2828// target=native
2929//
3030// :2:21: error: expected a tuple, found 'void'
31// :5:21: error: unable to perform 'never_inline' call at compile-time
32// :8:21: error: unable to perform 'never_tail' call at compile-time
31// :5:33: error: unable to perform 'never_inline' call at compile-time
32// :8:33: error: unable to perform 'never_tail' call at compile-time
3333// :11:5: error: no-inline call of inline function
3434// :15:43: error: modifier 'compile_time' requires a comptime-known function
3535// :19:44: error: modifier 'always_inline' requires a comptime-known function
test/cases/compile_errors/error_in_call_builtin_args.zig created+15
......@@ -0,0 +1,15 @@
1fn foo(_: u32, _: u32) void {}
2pub export fn entry() void {
3 @call(.{}, foo, .{ 12, 12.34 });
4}
5pub export fn entry1() void {
6 const args = .{ 12, 12.34 };
7 @call(.{}, foo, args);
8}
9
10// error
11// backend=stage2
12// target=native
13//
14// :3:28: error: fractional component prevents float value '12.34' from coercion to type 'u32'
15// :7:21: error: fractional component prevents float value '12.34' from coercion to type 'u32'
test/cases/compile_errors/export_with_empty_name_string.zig+1-1
......@@ -7,4 +7,4 @@ comptime {
77// backend=llvm
88// target=native
99//
10// :3:21: error: exported symbol name cannot be empty
10// :3:24: error: exported symbol name cannot be empty
test/cases/compile_errors/invalid_identifiers.zig created+33
......@@ -0,0 +1,33 @@
1extern "" var a: u32;
2extern "" fn b() void;
3
4extern "\x00" var c: u32;
5extern "\x00" fn d() void;
6
7test "" {}
8test "\x00" {}
9
10const e = @import("");
11const f = @import("\x00");
12
13comptime {
14 const @"" = undefined;
15}
16comptime {
17 const @"\x00" = undefined;
18}
19
20// error
21// backend=stage2
22// target=native
23//
24// :1:8: error: library name cannot be empty
25// :2:8: error: library name cannot be empty
26// :4:8: error: library name cannot contain null bytes
27// :5:8: error: library name cannot contain null bytes
28// :7:6: error: empty test name must be omitted
29// :8:6: error: test name cannot contain null bytes
30// :10:19: error: import path cannot be empty
31// :11:19: error: import path cannot contain null bytes
32// :14:11: error: identifier cannot be empty
33// :17:11: error: identifier cannot contain null bytes
test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig+1-1
......@@ -1,4 +1,4 @@
1test "" {}
1test {}
22
33pub fn panic() void {}
44
test/standalone/issue_9812/main.zig+1-1
......@@ -14,7 +14,7 @@ const Error = error{
1414 InvalidCmdLine,
1515};
1616
17test "" {
17test {
1818 const allocator = std.heap.c_allocator;
1919
2020 const args = try std.process.argsAlloc(allocator);