Commit 243afdcdf57d74a184784551aebe58062e5afc03 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-03-31 15:06:44-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-03-31 15:10:31-07:00
log	243afdcdf57d74a184784551aebe58062e5afc03
tree	7e637a4c50b8abf6beb1354c346fc08055c5f0e7
parent	df1ba38a88a255286af4d939d427f8a4ee667485

test harness improvements

 * `-Dskip-compile-errors` is removed; `-Dskip-stage1` is added.
 * Use `std.testing.allocator` instead of a new instance of GPA.
   - Fix the memory leaks this revealed.
 * Show the file name when it is not parsed correctly such as when the
   manifest is missing.
   - Better error messages when test files are not parsed correctly.
 * Ignore unknown files such as swap files.
 * Move logic from declarative file to the test harness implementation.
 * Move stage1 tests to stage2 tests where appropriate.

11 files changed, 184 insertions(+), 152 deletions(-)

build.zig
src
- test.zig
test
- compile_errors.zig
- compile_errors
  - stage1
    exe
    std.fmt_error_for_unused_arguments.zig
    obj
    constant_inside_comptime_function_has_compile_error.zig
    std.fmt_error_for_unused_arguments.zig
    unused_variable_error_on_errdefer.zig
    test
    duplicate-unused_labels.zig
    unused_variable_error_on_errdefer.zig
  - stage2
    constant_inside_comptime_function_has_compile_error.zig
    duplicate-unused_labels.zig

build.zig+2-2

...	...	@@ -54,7 +54,7 @@ pub fn build(b: *Builder) !void {
54	54	const skip_release_safe = b.option(bool, "skip-release-safe", "Main test suite skips release-safe builds") orelse skip_release;
55	55	const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse false;
56	56	const skip_libc = b.option(bool, "skip-libc", "Main test suite skips tests that link libc") orelse false;
57		const skip_compile_errors = b.option(bool, "skip-compile-errors", "Main test suite skips compile error tests") orelse false;
	57	const skip_stage1 = b.option(bool, "skip-stage1", "Main test suite skips stage1 compile error tests") orelse false;
58	58	const skip_run_translated_c = b.option(bool, "skip-run-translated-c", "Main test suite skips run-translated-c tests") orelse false;
59	59	const skip_stage2_tests = b.option(bool, "skip-stage2-tests", "Main test suite skips self-hosted compiler tests") orelse false;
60	60	const skip_install_lib_files = b.option(bool, "skip-install-lib-files", "Do not copy lib/ files to installation prefix") orelse false;
...	...	@@ -386,7 +386,7 @@ pub fn build(b: *Builder) !void {
386	386	test_stage2_options.addOption(bool, "enable_logging", enable_logging);
387	387	test_stage2_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
388	388	test_stage2_options.addOption(bool, "skip_non_native", skip_non_native);
389		test_stage2_options.addOption(bool, "skip_compile_errors", skip_compile_errors);
	389	test_stage2_options.addOption(bool, "skip_stage1", skip_stage1);
390	390	test_stage2_options.addOption(bool, "is_stage1", is_stage1);
391	391	test_stage2_options.addOption(bool, "omit_stage2", omit_stage2);
392	392	test_stage2_options.addOption(bool, "have_llvm", enable_llvm);

src/test.zig+114-45

...	...	@@ -12,7 +12,7 @@ const enable_wasmtime: bool = build_options.enable_wasmtime;
12	12	const enable_darling: bool = build_options.enable_darling;
13	13	const enable_rosetta: bool = build_options.enable_rosetta;
14	14	const glibc_runtimes_dir: ?[]const u8 = build_options.glibc_runtimes_dir;
15		const skip_compile_errors = build_options.skip_compile_errors;
	15	const skip_stage1 = build_options.skip_stage1;
16	16	const ThreadPool = @import("ThreadPool.zig");
17	17	const CrossTarget = std.zig.CrossTarget;
18	18	const print = std.debug.print;
...	...	@@ -20,7 +20,6 @@ const assert = std.debug.assert;
20	20
21	21	const zig_h = link.File.C.zig_h;
22	22
23		var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
24	23	const hr = "=" ** 80;
25	24
26	25	test {
...	...	@@ -28,9 +27,50 @@ test {
28	27	@import("stage1.zig").os_init();
29	28	}
30	29
31		var ctx = TestContext.init();
	30	var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
	31	defer arena_allocator.deinit();
	32	const arena = arena_allocator.allocator();
	33
	34	var ctx = TestContext.init(std.testing.allocator, arena);
32	35	defer ctx.deinit();
33	36
	37	const compile_errors_dir_path = try std.fs.path.join(arena, &.{
	38	std.fs.path.dirname(@src().file).?, "..", "test", "compile_errors",
	39	});
	40
	41	var compile_errors_dir = try std.fs.cwd().openDir(compile_errors_dir_path, .{});
	42	defer compile_errors_dir.close();
	43
	44	{
	45	var stage2_dir = try compile_errors_dir.openDir("stage2", .{ .iterate = true });
	46	defer stage2_dir.close();
	47
	48	// TODO make this incremental once the bug is solved that it triggers
	49	ctx.addErrorCasesFromDir("stage2", stage2_dir, .stage2, .Obj, false, .independent);
	50	}
	51
	52	if (!skip_stage1) {
	53	var stage1_dir = try compile_errors_dir.openDir("stage1", .{});
	54	defer stage1_dir.close();
	55
	56	const Config = struct {
	57	name: []const u8,
	58	is_test: bool,
	59	output_mode: std.builtin.OutputMode,
	60	};
	61
	62	for ([_]Config{
	63	.{ .name = "obj", .is_test = false, .output_mode = .Obj },
	64	.{ .name = "exe", .is_test = false, .output_mode = .Exe },
	65	.{ .name = "test", .is_test = true, .output_mode = .Exe },
	66	}) \|config\| {
	67	var dir = try stage1_dir.openDir(config.name, .{ .iterate = true });
	68	defer dir.close();
	69
	70	ctx.addErrorCasesFromDir("stage1", dir, .stage1, config.output_mode, config.is_test, .independent);
	71	}
	72	}
	73
34	74	try @import("test_cases").addCases(&ctx);
35	75
36	76	try ctx.run();
...	...	@@ -114,6 +154,7 @@ const ErrorMsg = union(enum) {
114	154	};
115	155
116	156	pub const TestContext = struct {
	157	arena: Allocator,
117	158	cases: std.ArrayList(Case),
118	159
119	160	pub const Update = struct {
...	...	@@ -316,7 +357,7 @@ pub const TestContext = struct {
316	357	.target = target,
317	358	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
318	359	.output_mode = .Exe,
319		.files = std.ArrayList(File).init(ctx.cases.allocator),
	360	.files = std.ArrayList(File).init(ctx.arena),
320	361	}) catch @panic("out of memory");
321	362	return &ctx.cases.items[ctx.cases.items.len - 1];
322	363	}
...	...	@@ -327,7 +368,7 @@ pub const TestContext = struct {
327	368	}
328	369
329	370	pub fn exeFromCompiledC(ctx: TestContext, name: []const u8, target: CrossTarget) Case {
330		const prefixed_name = std.fmt.allocPrint(ctx.cases.allocator, "CBE: {s}", .{name}) catch
	371	const prefixed_name = std.fmt.allocPrint(ctx.arena, "CBE: {s}", .{name}) catch
331	372	@panic("out of memory");
332	373	ctx.cases.append(Case{
333	374	.name = prefixed_name,
...	...	@@ -335,7 +376,7 @@ pub const TestContext = struct {
335	376	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
336	377	.output_mode = .Exe,
337	378	.object_format = .c,
338		.files = std.ArrayList(File).init(ctx.cases.allocator),
	379	.files = std.ArrayList(File).init(ctx.arena),
339	380	}) catch @panic("out of memory");
340	381	return &ctx.cases.items[ctx.cases.items.len - 1];
341	382	}
...	...	@@ -348,7 +389,7 @@ pub const TestContext = struct {
348	389	.target = target,
349	390	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
350	391	.output_mode = .Exe,
351		.files = std.ArrayList(File).init(ctx.cases.allocator),
	392	.files = std.ArrayList(File).init(ctx.arena),
352	393	.backend = .llvm,
353	394	.link_libc = true,
354	395	}) catch @panic("out of memory");
...	...	@@ -365,7 +406,7 @@ pub const TestContext = struct {
365	406	.target = target,
366	407	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
367	408	.output_mode = .Obj,
368		.files = std.ArrayList(File).init(ctx.cases.allocator),
	409	.files = std.ArrayList(File).init(ctx.arena),
369	410	}) catch @panic("out of memory");
370	411	return &ctx.cases.items[ctx.cases.items.len - 1];
371	412	}
...	...	@@ -381,7 +422,7 @@ pub const TestContext = struct {
381	422	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
382	423	.output_mode = .Exe,
383	424	.is_test = true,
384		.files = std.ArrayList(File).init(ctx.cases.allocator),
	425	.files = std.ArrayList(File).init(ctx.arena),
385	426	}) catch @panic("out of memory");
386	427	return &ctx.cases.items[ctx.cases.items.len - 1];
387	428	}
...	...	@@ -404,7 +445,7 @@ pub const TestContext = struct {
404	445	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
405	446	.output_mode = .Obj,
406	447	.object_format = .c,
407		.files = std.ArrayList(File).init(ctx.cases.allocator),
	448	.files = std.ArrayList(File).init(ctx.arena),
408	449	}) catch @panic("out of memory");
409	450	return &ctx.cases.items[ctx.cases.items.len - 1];
410	451	}
...	...	@@ -423,7 +464,7 @@ pub const TestContext = struct {
423	464	src: [:0]const u8,
424	465	expected_errors: []const []const u8,
425	466	) void {
426		if (skip_compile_errors) return;
	467	if (skip_stage1) return;
427	468
428	469	const case = ctx.addObj(name, .{});
429	470	case.backend = .stage1;
...	...	@@ -436,7 +477,7 @@ pub const TestContext = struct {
436	477	src: [:0]const u8,
437	478	expected_errors: []const []const u8,
438	479	) void {
439		if (skip_compile_errors) return;
	480	if (skip_stage1) return;
440	481
441	482	const case = ctx.addTest(name, .{});
442	483	case.backend = .stage1;
...	...	@@ -449,7 +490,7 @@ pub const TestContext = struct {
449	490	src: [:0]const u8,
450	491	expected_errors: []const []const u8,
451	492	) void {
452		if (skip_compile_errors) return;
	493	if (skip_stage1) return;
453	494
454	495	const case = ctx.addExe(name, .{});
455	496	case.backend = .stage1;
...	...	@@ -612,6 +653,8 @@ pub const TestContext = struct {
612	653	case.compiles(fixed_src);
613	654	}
614	655
	656	const Strategy = enum { incremental, independent };
	657
615	658	/// Adds a compile-error test for each file in the provided directory, using the
616	659	/// selected backend and output mode. If `one_test_case_per_file` is true, a new
617	660	/// test case is created for each file. Otherwise, a single test case is used for
...	...	@@ -628,33 +671,58 @@ pub const TestContext = struct {
628	671	backend: Backend,
629	672	output_mode: std.builtin.OutputMode,
630	673	is_test: bool,
631		one_test_case_per_file: bool,
632		) !void {
633		if (skip_compile_errors) return;
	674	strategy: Strategy,
	675	) void {
	676	var current_file: []const u8 = "none";
	677	addErrorCasesFromDirInner(ctx, name, dir, backend, output_mode, is_test, strategy, &current_file) catch \|err\| {
	678	std.debug.panic("test harness failed to process file '{s}': {s}\n", .{
	679	current_file, @errorName(err),
	680	});
	681	};
	682	}
634	683
635		const gpa = general_purpose_allocator.allocator();
	684	fn addErrorCasesFromDirInner(
	685	ctx: *TestContext,
	686	name: []const u8,
	687	dir: std.fs.Dir,
	688	backend: Backend,
	689	output_mode: std.builtin.OutputMode,
	690	is_test: bool,
	691	strategy: Strategy,
	692	/// This is kept up to date with the currently being processed file so
	693	/// that if any errors occur the caller knows it happened during this file.
	694	current_file: *[]const u8,
	695	) !void {
636	696	var opt_case: ?*Case = null;
637	697
638	698	var it = dir.iterate();
639	699	while (try it.next()) \|entry\| {
640	700	if (entry.kind != .File) continue;
641	701
642		var contents = try dir.readFileAlloc(gpa, entry.name, std.math.maxInt(u32));
643		defer gpa.free(contents);
	702	// Ignore stuff such as .swp files
	703	switch (Compilation.classifyFileExt(entry.name)) {
	704	.unknown => continue,
	705	else => {},
	706	}
	707
	708	current_file.* = try ctx.arena.dupe(u8, entry.name);
	709
	710	const max_file_size = 10 * 1024 * 1024;
	711	const src = try dir.readFileAllocOptions(ctx.arena, entry.name, max_file_size, null, 1, 0);
644	712
645	713	// The manifest is the last contiguous block of comments in the file
646	714	// We scan for the beginning by searching backward for the first non-empty line that does not start with "//"
647	715	var manifest_start: ?usize = null;
648		var manifest_end: usize = contents.len;
649		if (contents.len > 0) {
650		var cursor: usize = contents.len - 1;
	716	var manifest_end: usize = src.len;
	717	if (src.len > 0) {
	718	var cursor: usize = src.len - 1;
651	719	while (true) {
652	720	// Move to beginning of line
653		while (cursor > 0 and contents[cursor - 1] != '\n') cursor -= 1;
	721	while (cursor > 0 and src[cursor - 1] != '\n') cursor -= 1;
654	722
655	723	// Check if line is non-empty and does not start with "//"
656		if (cursor + 1 < contents.len and contents[cursor + 1] != '\n' and contents[cursor + 1] != '\r') {
657		if (std.mem.startsWith(u8, contents[cursor..], "//")) {
	724	if (cursor + 1 < src.len and src[cursor + 1] != '\n' and src[cursor + 1] != '\r') {
	725	if (std.mem.startsWith(u8, src[cursor..], "//")) {
658	726	manifest_start = cursor;
659	727	} else {
660	728	break;
...	...	@@ -666,27 +734,23 @@ pub const TestContext = struct {
666	734	}
667	735	}
668	736
669		var errors = std.ArrayList([]const u8).init(gpa);
670		defer errors.deinit();
	737	var errors = std.ArrayList([]const u8).init(ctx.arena);
671	738
672	739	if (manifest_start) \|start\| {
673	740	// Due to the above processing, we know that this is a contiguous block of comments
674		var manifest_it = std.mem.tokenize(u8, contents[start..manifest_end], "\r\n");
	741	var manifest_it = std.mem.tokenize(u8, src[start..manifest_end], "\r\n");
675	742
676	743	// First line is the test case name
677		const first_line = manifest_it.next() orelse return error.InvalidFile;
678		const case_name = try std.mem.concat(gpa, u8, &.{ name, ": ", std.mem.trim(u8, first_line[2..], " \t") });
	744	const first_line = manifest_it.next() orelse return error.MissingTestCaseName;
	745	const case_name = try std.mem.concat(ctx.arena, u8, &.{ name, ": ", std.mem.trim(u8, first_line[2..], " \t") });
679	746
680	747	// If the second line is present, it should be blank
681	748	if (manifest_it.next()) \|second_line\| {
682		if (std.mem.trim(u8, second_line[2..], " \t").len != 0) return error.InvalidFile;
	749	if (std.mem.trim(u8, second_line[2..], " \t").len != 0) return error.SecondLineNotBlank;
683	750	}
684	751
685	752	// All following lines are expected error messages
686		while (manifest_it.next()) \|line\| try errors.append(try gpa.dupe(u8, std.mem.trim(u8, line[2..], " \t")));
687
688		// The entire file contents is the source, including the manifest
689		const src = try gpa.dupeZ(u8, contents);
	753	while (manifest_it.next()) \|line\| try errors.append(try ctx.arena.dupe(u8, std.mem.trim(u8, line[2..], " \t")));
690	754
691	755	const case = opt_case orelse case: {
692	756	ctx.cases.append(TestContext.Case{
...	...	@@ -702,22 +766,27 @@ pub const TestContext = struct {
702	766	opt_case = case;
703	767	break :case case;
704	768	};
705		if (one_test_case_per_file) {
706		case.name = case_name;
707		case.addError(src, errors.items);
708		opt_case = null;
709		} else {
710		case.addErrorNamed(case_name, src, errors.items);
	769	switch (strategy) {
	770	.independent => {
	771	case.name = case_name;
	772	case.addError(src, errors.items);
	773	opt_case = null;
	774	},
	775	.incremental => {
	776	case.addErrorNamed(case_name, src, errors.items);
	777	},
711	778	}
712	779	} else {
713		return error.InvalidFile; // Manifests are currently mandatory
	780	return error.MissingManifest;
714	781	}
715	782	}
716	783	}
717	784
718		fn init() TestContext {
719		const allocator = std.heap.page_allocator;
720		return .{ .cases = std.ArrayList(Case).init(allocator) };
	785	fn init(gpa: Allocator, arena: Allocator) TestContext {
	786	return .{
	787	.cases = std.ArrayList(Case).init(gpa),
	788	.arena = arena,
	789	};
721	790	}
722	791
723	792	fn deinit(self: *TestContext) void {

test/compile_errors.zig-38

...	...	@@ -3,44 +3,6 @@ const builtin = @import("builtin");
3	3	const TestContext = @import("../src/test.zig").TestContext;
4	4
5	5	pub fn addCases(ctx: *TestContext) !void {
6		var parent_dir = try std.fs.cwd().openDir(std.fs.path.dirname(@src().file).?, .{ .no_follow = true });
7		defer parent_dir.close();
8
9		var compile_errors_dir = try parent_dir.openDir("compile_errors", .{ .no_follow = true });
10		defer compile_errors_dir.close();
11
12		{
13		var stage2_dir = try compile_errors_dir.openDir("stage2", .{ .iterate = true, .no_follow = true });
14		defer stage2_dir.close();
15
16		// TODO make this false once the bug is solved that it triggers
17		const one_test_case_per_file = true;
18		try ctx.addErrorCasesFromDir("stage2", stage2_dir, .stage2, .Obj, false, one_test_case_per_file);
19		}
20
21		{
22		var stage1_dir = try compile_errors_dir.openDir("stage1", .{ .no_follow = true });
23		defer stage1_dir.close();
24		{
25		const one_test_case_per_file = true;
26
27		var obj_dir = try stage1_dir.openDir("obj", .{ .iterate = true, .no_follow = true });
28		defer obj_dir.close();
29
30		try ctx.addErrorCasesFromDir("stage1", obj_dir, .stage1, .Obj, false, one_test_case_per_file);
31
32		var exe_dir = try stage1_dir.openDir("exe", .{ .iterate = true, .no_follow = true });
33		defer exe_dir.close();
34
35		try ctx.addErrorCasesFromDir("stage1", exe_dir, .stage1, .Exe, false, one_test_case_per_file);
36
37		var test_dir = try stage1_dir.openDir("test", .{ .iterate = true, .no_follow = true });
38		defer test_dir.close();
39
40		try ctx.addErrorCasesFromDir("stage1", test_dir, .stage1, .Exe, true, one_test_case_per_file);
41		}
42		}
43
44	6	{
45	7	const case = ctx.obj("callconv(.Interrupt) on unsupported platform", .{
46	8	.cpu_arch = .aarch64,

test/compile_errors/stage1/exe/std.fmt_error_for_unused_arguments.zig deleted-7

...	...	@@ -1,7 +0,0 @@
1		pub fn main() !void {
2		@import("std").debug.print("{d} {d} {d} {d} {d}", .{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15});
3		}
4
5		// std.fmt error for unused arguments
6		//
7		// ?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'

test/compile_errors/stage1/obj/constant_inside_comptime_function_has_compile_error.zig deleted-19

...	...	@@ -1,19 +0,0 @@
1		const ContextAllocator = MemoryPool(usize);
2
3		pub fn MemoryPool(comptime T: type) type {
4		const free_list_t = @compileError("aoeu",);
5
6		return struct {
7		free_list: free_list_t,
8		};
9		}
10
11		export fn entry() void {
12		var allocator: ContextAllocator = undefined;
13		}
14
15		// constant inside comptime function has compile error
16		//
17		// tmp.zig:4:5: error: unreachable code
18		// tmp.zig:4:25: note: control flow is diverted here
19		// tmp.zig:12:9: error: unused local variable

test/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig created+7

...	...	@@ -0,0 +1,7 @@
	1	export fn entry() void {
	2	@import("std").debug.print("{d} {d} {d} {d} {d}", .{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15});
	3	}
	4
	5	// std.fmt error for unused arguments
	6	//
	7	// ?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'

test/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig created+11

...	...	@@ -0,0 +1,11 @@
	1	fn foo() !void {
	2	errdefer \|a\| unreachable;
	3	return error.A;
	4	}
	5	export fn entry() void {
	6	foo() catch unreachable;
	7	}
	8
	9	// unused variable error on errdefer
	10	//
	11	// tmp.zig:2:15: error: unused variable: 'a'

test/compile_errors/stage1/test/duplicate-unused_labels.zig deleted-30

...	...	@@ -1,30 +0,0 @@
1		comptime {
2		blk: { blk: while (false) {} }
3		}
4		comptime {
5		blk: while (false) { blk: for (@as([0]void, undefined)) \|_\| {} }
6		}
7		comptime {
8		blk: for (@as([0]void, undefined)) \|_\| { blk: {} }
9		}
10		comptime {
11		blk: {}
12		}
13		comptime {
14		blk: while(false) {}
15		}
16		comptime {
17		blk: for(@as([0]void, undefined)) \|_\| {}
18		}
19
20		// duplicate/unused labels
21		//
22		// tmp.zig:2:12: error: redefinition of label 'blk'
23		// tmp.zig:2:5: note: previous definition here
24		// tmp.zig:5:26: error: redefinition of label 'blk'
25		// tmp.zig:5:5: note: previous definition here
26		// tmp.zig:8:46: error: redefinition of label 'blk'
27		// tmp.zig:8:5: note: previous definition here
28		// tmp.zig:11:5: error: unused block label
29		// tmp.zig:14:5: error: unused while loop label
30		// tmp.zig:17:5: error: unused for loop label

test/compile_errors/stage1/test/unused_variable_error_on_errdefer.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		fn foo() !void {
2		errdefer \|a\| unreachable;
3		return error.A;
4		}
5		export fn entry() void {
6		foo() catch unreachable;
7		}
8
9		// unused variable error on errdefer
10		//
11		// tmp.zig:2:15: error: unused variable: 'a'

test/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig created+20

...	...	@@ -0,0 +1,20 @@
	1	const ContextAllocator = MemoryPool(usize);
	2
	3	pub fn MemoryPool(comptime T: type) type {
	4	const free_list_t = @compileError("aoeu",);
	5	_ = T;
	6
	7	return struct {
	8	free_list: free_list_t,
	9	};
	10	}
	11
	12	export fn entry() void {
	13	var allocator: ContextAllocator = undefined;
	14	_ = allocator;
	15	}
	16
	17	// constant inside comptime function has compile error
	18	//
	19	// :4:5: error: unreachable code
	20	// :4:25: note: control flow is diverted here

test/compile_errors/stage2/duplicate-unused_labels.zig created+30

...	...	@@ -0,0 +1,30 @@
	1	comptime {
	2	blk: { blk: while (false) {} }
	3	}
	4	comptime {
	5	blk: while (false) { blk: for (@as([0]void, undefined)) \|_\| {} }
	6	}
	7	comptime {
	8	blk: for (@as([0]void, undefined)) \|_\| { blk: {} }
	9	}
	10	comptime {
	11	blk: {}
	12	}
	13	comptime {
	14	blk: while(false) {}
	15	}
	16	comptime {
	17	blk: for(@as([0]void, undefined)) \|_\| {}
	18	}
	19
	20	// duplicate/unused labels
	21	//
	22	// :2:12: error: redefinition of label 'blk'
	23	// :2:5: note: previous definition here
	24	// :5:26: error: redefinition of label 'blk'
	25	// :5:5: note: previous definition here
	26	// :8:46: error: redefinition of label 'blk'
	27	// :8:5: note: previous definition here
	28	// :11:5: error: unused block label
	29	// :14:5: error: unused while loop label
	30	// :17:5: error: unused for loop label