Commit bb98620c10992884d58ae97a3a30dd9e26735fea | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-07-02 21:11:45-04:00
committer	GitHub <noreply@github.com> 2021-07-02 21:11:45-04:00
log	bb98620c10992884d58ae97a3a30dd9e26735fea
tree	463cb67f3551c397aae17dff5594cd2fd2037ca0
parent	d84b386f6034278c8a9e8c3d2b0975ac541584aa
parent	a6bf68ccf985787eeac33a97e362d043987905c4
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #9219 from ziglang/unreachable-code

move "unreachable code" error from stage1 to stage2

35 files changed, 4342 insertions(+), 3748 deletions(-)

build.zig
doc
- docgen.zig
- langref.html.in
lib
- std
  - fmt.zig
  - mem.zig
  - os
    uefi
    protocols
    simple_network_protocol.zig
  - unicode.zig
  - zig.zig
  - zig
    ast.zig
    parse.zig
    parser_test.zig
    tokenizer.zig
src
- AstGen.zig
- Compilation.zig
- Module.zig
- Zir.zig
- link.zig
- link
  - MachO.zig
  - Wasm.zig
- main.zig
- stage1.zig
- stage1
- target.zig
- test.zig
- translate_c
  - ast.zig
test
- cases.zig
- compile_errors.zig
- stage2
- tests.zig

build.zig+20-12

...	...	@@ -40,7 +40,7 @@ pub fn build(b: *Builder) !void {
40	40
41	41	var test_stage2 = b.addTest("src/test.zig");
42	42	test_stage2.setBuildMode(mode);
43		test_stage2.addPackagePath("stage2_tests", "test/stage2/test.zig");
	43	test_stage2.addPackagePath("test_cases", "test/cases.zig");
44	44
45	45	const fmt_build_zig = b.addFmt(&[_][]const u8{"build.zig"});
46	46
...	...	@@ -113,11 +113,15 @@ pub fn build(b: *Builder) !void {
113	113	if (is_stage1) {
114	114	exe.addIncludeDir("src");
115	115	exe.addIncludeDir("deps/SoftFloat-3e/source/include");
	116
	117	test_stage2.addIncludeDir("src");
	118	test_stage2.addIncludeDir("deps/SoftFloat-3e/source/include");
116	119	// This is intentionally a dummy path. stage1.zig tries to @import("compiler_rt") in case
117	120	// of being built by cmake. But when built by zig it's gonna get a compiler_rt so that
118	121	// is pointless.
119	122	exe.addPackagePath("compiler_rt", "src/empty.zig");
120	123	exe.defineCMacro("ZIG_LINK_MODE", "Static");
	124	test_stage2.defineCMacro("ZIG_LINK_MODE", "Static");
121	125
122	126	const softfloat = b.addStaticLibrary("softfloat", null);
123	127	softfloat.setBuildMode(.ReleaseFast);
...	...	@@ -126,10 +130,15 @@ pub fn build(b: *Builder) !void {
126	130	softfloat.addIncludeDir("deps/SoftFloat-3e/source/8086");
127	131	softfloat.addIncludeDir("deps/SoftFloat-3e/source/include");
128	132	softfloat.addCSourceFiles(&softfloat_sources, &[_][]const u8{ "-std=c99", "-O3" });
	133
129	134	exe.linkLibrary(softfloat);
	135	test_stage2.linkLibrary(softfloat);
130	136
131	137	exe.addCSourceFiles(&stage1_sources, &exe_cflags);
132	138	exe.addCSourceFiles(&optimized_c_sources, &[_][]const u8{ "-std=c99", "-O3" });
	139
	140	test_stage2.addCSourceFiles(&stage1_sources, &exe_cflags);
	141	test_stage2.addCSourceFiles(&optimized_c_sources, &[_][]const u8{ "-std=c99", "-O3" });
133	142	}
134	143	if (cmake_cfg) \|cfg\| {
135	144	// Inside this code path, we have to coordinate with system packaged LLVM, Clang, and LLD.
...	...	@@ -139,8 +148,8 @@ pub fn build(b: *Builder) !void {
139	148	b.addSearchPrefix(cfg.cmake_prefix_path);
140	149	}
141	150
142		try addCmakeCfgOptionsToExe(b, cfg, tracy, exe);
143		try addCmakeCfgOptionsToExe(b, cfg, tracy, test_stage2);
	151	try addCmakeCfgOptionsToExe(b, cfg, exe);
	152	try addCmakeCfgOptionsToExe(b, cfg, test_stage2);
144	153	} else {
145	154	// Here we are -Denable-llvm but no cmake integration.
146	155	try addStaticLlvmOptionsToExe(exe);
...	...	@@ -233,7 +242,9 @@ pub fn build(b: *Builder) !void {
233	242	const is_darling_enabled = b.option(bool, "enable-darling", "[Experimental] Use Darling to run cross compiled macOS tests") orelse false;
234	243	const glibc_multi_dir = b.option([]const u8, "enable-foreign-glibc", "Provide directory with glibc installations to run cross compiled tests that link glibc");
235	244
	245	test_stage2.addBuildOption(bool, "enable_logging", enable_logging);
236	246	test_stage2.addBuildOption(bool, "skip_non_native", skip_non_native);
	247	test_stage2.addBuildOption(bool, "skip_compile_errors", skip_compile_errors);
237	248	test_stage2.addBuildOption(bool, "is_stage1", is_stage1);
238	249	test_stage2.addBuildOption(bool, "omit_stage2", omit_stage2);
239	250	test_stage2.addBuildOption(bool, "have_llvm", enable_llvm);
...	...	@@ -243,7 +254,8 @@ pub fn build(b: *Builder) !void {
243	254	test_stage2.addBuildOption(u32, "mem_leak_frames", mem_leak_frames * 2);
244	255	test_stage2.addBuildOption(bool, "enable_darling", is_darling_enabled);
245	256	test_stage2.addBuildOption(?[]const u8, "glibc_multi_install_dir", glibc_multi_dir);
246		test_stage2.addBuildOption([]const u8, "version", version);
	257	test_stage2.addBuildOption([:0]const u8, "version", try b.allocator.dupeZ(u8, version));
	258	test_stage2.addBuildOption(std.SemanticVersion, "semver", semver);
247	259
248	260	const test_stage2_step = b.step("test-stage2", "Run the stage2 compiler tests");
249	261	test_stage2_step.dependOn(&test_stage2.step);
...	...	@@ -339,9 +351,6 @@ pub fn build(b: *Builder) !void {
339	351	}
340	352	// tests for this feature are disabled until we have the self-hosted compiler available
341	353	// toolchain_step.dependOn(tests.addGenHTests(b, test_filter));
342		if (!skip_compile_errors) {
343		toolchain_step.dependOn(tests.addCompileErrorTests(b, test_filter, modes));
344		}
345	354
346	355	const std_step = tests.addPkgTests(
347	356	b,
...	...	@@ -383,7 +392,6 @@ const exe_cflags = [_][]const u8{
383	392	fn addCmakeCfgOptionsToExe(
384	393	b: *Builder,
385	394	cfg: CMakeConfig,
386		tracy: ?[]const u8,
387	395	exe: *std.build.LibExeObjStep,
388	396	) !void {
389	397	exe.addObjectFile(fs.path.join(b.allocator, &[_][]const u8{
...	...	@@ -397,7 +405,7 @@ fn addCmakeCfgOptionsToExe(
397	405	addCMakeLibraryList(exe, cfg.lld_libraries);
398	406	addCMakeLibraryList(exe, cfg.llvm_libraries);
399	407
400		const need_cpp_includes = tracy != null;
	408	const need_cpp_includes = true;
401	409
402	410	// System -lc++ must be used because in this code path we are attempting to link
403	411	// against system-provided LLVM, Clang, LLD.
...	...	@@ -486,9 +494,9 @@ fn addCxxKnownPath(
486	494	if (need_cpp_includes) {
487	495	// I used these temporarily for testing something but we obviously need a
488	496	// more general purpose solution here.
489		//exe.addIncludeDir("/nix/store/b3zsk4ihlpiimv3vff86bb5bxghgdzb9-gcc-9.2.0/lib/gcc/x86_64-unknown-linux-gnu/9.2.0/../../../../include/c++/9.2.0");
490		//exe.addIncludeDir("/nix/store/b3zsk4ihlpiimv3vff86bb5bxghgdzb9-gcc-9.2.0/lib/gcc/x86_64-unknown-linux-gnu/9.2.0/../../../../include/c++/9.2.0/x86_64-unknown-linux-gnu");
491		//exe.addIncludeDir("/nix/store/b3zsk4ihlpiimv3vff86bb5bxghgdzb9-gcc-9.2.0/lib/gcc/x86_64-unknown-linux-gnu/9.2.0/../../../../include/c++/9.2.0/backward");
	497	//exe.addIncludeDir("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0");
	498	//exe.addIncludeDir("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/x86_64-unknown-linux-gnu");
	499	//exe.addIncludeDir("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/backward");
492	500	}
493	501	}
494	502

doc/docgen.zig+34-14

...	...	@@ -8,6 +8,7 @@ const Progress = std.Progress;
8	8	const print = std.debug.print;
9	9	const mem = std.mem;
10	10	const testing = std.testing;
	11	const Allocator = std.mem.Allocator;
11	12
12	13	const max_doc_file_size = 10 * 1024 * 1024;
13	14
...	...	@@ -326,7 +327,7 @@ const Action = enum {
326	327	Close,
327	328	};
328	329
329		fn genToc(allocator: mem.Allocator, tokenizer: Tokenizer) !Toc {
	330	fn genToc(allocator: Allocator, tokenizer: Tokenizer) !Toc {
330	331	var urls = std.StringHashMap(Token).init(allocator);
331	332	errdefer urls.deinit();
332	333
...	...	@@ -630,7 +631,7 @@ fn genToc(allocator: mem.Allocator, tokenizer: Tokenizer) !Toc {
630	631	};
631	632	}
632	633
633		fn urlize(allocator: *mem.Allocator, input: []const u8) ![]u8 {
	634	fn urlize(allocator: *Allocator, input: []const u8) ![]u8 {
634	635	var buf = std.ArrayList(u8).init(allocator);
635	636	defer buf.deinit();
636	637
...	...	@@ -649,7 +650,7 @@ fn urlize(allocator: *mem.Allocator, input: []const u8) ![]u8 {
649	650	return buf.toOwnedSlice();
650	651	}
651	652
652		fn escapeHtml(allocator: *mem.Allocator, input: []const u8) ![]u8 {
	653	fn escapeHtml(allocator: *Allocator, input: []const u8) ![]u8 {
653	654	var buf = std.ArrayList(u8).init(allocator);
654	655	defer buf.deinit();
655	656
...	...	@@ -695,7 +696,7 @@ test "term color" {
695	696	testing.expectEqualSlices(u8, "A<span class=\"t32\">green</span>B", result);
696	697	}
697	698
698		fn termColor(allocator: *mem.Allocator, input: []const u8) ![]u8 {
	699	fn termColor(allocator: *Allocator, input: []const u8) ![]u8 {
699	700	var buf = std.ArrayList(u8).init(allocator);
700	701	defer buf.deinit();
701	702
...	...	@@ -789,8 +790,15 @@ fn isType(name: []const u8) bool {
789	790	return false;
790	791	}
791	792
792		fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token: Token, raw_src: []const u8) !void {
793		const src = mem.trim(u8, raw_src, " \n");
	793	fn tokenizeAndPrintRaw(
	794	allocator: *Allocator,
	795	docgen_tokenizer: *Tokenizer,
	796	out: anytype,
	797	source_token: Token,
	798	raw_src: []const u8,
	799	) !void {
	800	const src_non_terminated = mem.trim(u8, raw_src, " \n");
	801	const src = try allocator.dupeZ(u8, src_non_terminated);
794	802	try out.writeAll("<code class=\"zig\">");
795	803	var tokenizer = std.zig.Tokenizer.init(src);
796	804	var index: usize = 0;
...	...	@@ -1016,12 +1024,24 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token:
1016	1024	try out.writeAll("</code>");
1017	1025	}
1018	1026
1019		fn tokenizeAndPrint(docgen_tokenizer: *Tokenizer, out: anytype, source_token: Token) !void {
	1027	fn tokenizeAndPrint(
	1028	allocator: *Allocator,
	1029	docgen_tokenizer: *Tokenizer,
	1030	out: anytype,
	1031	source_token: Token,
	1032	) !void {
1020	1033	const raw_src = docgen_tokenizer.buffer[source_token.start..source_token.end];
1021		return tokenizeAndPrintRaw(docgen_tokenizer, out, source_token, raw_src);
	1034	return tokenizeAndPrintRaw(allocator, docgen_tokenizer, out, source_token, raw_src);
1022	1035	}
1023	1036
1024		fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: anytype, zig_exe: []const u8, do_code_tests: bool) !void {
	1037	fn genHtml(
	1038	allocator: *Allocator,
	1039	tokenizer: *Tokenizer,
	1040	toc: *Toc,
	1041	out: anytype,
	1042	zig_exe: []const u8,
	1043	do_code_tests: bool,
	1044	) !void {
1025	1045	var progress = Progress{};
1026	1046	const root_node = try progress.start("Generating docgen examples", toc.nodes.len);
1027	1047	defer root_node.end();
...	...	@@ -1048,7 +1068,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: any
1048	1068	},
1049	1069	.Builtin => \|tok\| {
1050	1070	try out.writeAll("<pre>");
1051		try tokenizeAndPrintRaw(tokenizer, out, tok, builtin_code);
	1071	try tokenizeAndPrintRaw(allocator, tokenizer, out, tok, builtin_code);
1052	1072	try out.writeAll("</pre>");
1053	1073	},
1054	1074	.HeaderOpen => \|info\| {
...	...	@@ -1069,7 +1089,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: any
1069	1089	try out.writeAll("</ul>\n");
1070	1090	},
1071	1091	.Syntax => \|content_tok\| {
1072		try tokenizeAndPrint(tokenizer, out, content_tok);
	1092	try tokenizeAndPrint(allocator, tokenizer, out, content_tok);
1073	1093	},
1074	1094	.Code => \|code\| {
1075	1095	const raw_source = tokenizer.buffer[code.source_token.start..code.source_token.end];
...	...	@@ -1078,7 +1098,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: any
1078	1098	try out.print("<p class=\"file\">{s}.zig</p>", .{code.name});
1079	1099	}
1080	1100	try out.writeAll("<pre>");
1081		try tokenizeAndPrint(tokenizer, out, code.source_token);
	1101	try tokenizeAndPrint(allocator, tokenizer, out, code.source_token);
1082	1102	try out.writeAll("</pre>");
1083	1103
1084	1104	if (!do_code_tests) {
...	...	@@ -1497,7 +1517,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: any
1497	1517	}
1498	1518	}
1499	1519
1500		fn exec(allocator: mem.Allocator, env_map: std.BufMap, args: []const []const u8) !ChildProcess.ExecResult {
	1520	fn exec(allocator: Allocator, env_map: std.BufMap, args: []const []const u8) !ChildProcess.ExecResult {
1501	1521	const result = try ChildProcess.exec(.{
1502	1522	.allocator = allocator,
1503	1523	.argv = args,
...	...	@@ -1521,7 +1541,7 @@ fn exec(allocator: mem.Allocator, env_map: std.BufMap, args: []const []const u
1521	1541	return result;
1522	1542	}
1523	1543
1524		fn getBuiltinCode(allocator: mem.Allocator, env_map: std.BufMap, zig_exe: []const u8) ![]const u8 {
	1544	fn getBuiltinCode(allocator: Allocator, env_map: std.BufMap, zig_exe: []const u8) ![]const u8 {
1525	1545	const result = try exec(allocator, env_map, &[_][]const u8{ zig_exe, "build-obj", "--show-builtin" });
1526	1546	return result.stdout;
1527	1547	}

doc/langref.html.in+18-6

...	...	@@ -3025,7 +3025,7 @@ test "@tagName" {
3025	3025	</p>
3026	3026	{#code_begin\|obj_err\|parameter of type 'Foo' not allowed in function with calling convention 'C'#}
3027	3027	const Foo = enum { a, b, c };
3028		export fn entry(foo: Foo) void { }
	3028	export fn entry(foo: Foo) void { _ = foo; }
3029	3029	{#code_end#}
3030	3030	<p>
3031	3031	For a C-ABI-compatible enum, provide an explicit tag type to
...	...	@@ -3346,7 +3346,7 @@ test "call foo" {
3346	3346	<p>
3347	3347	Blocks are used to limit the scope of variable declarations:
3348	3348	</p>
3349		{#code_begin\|test_err\|undeclared identifier#}
	3349	{#code_begin\|test_err\|unused local variable#}
3350	3350	test "access variable after block scope" {
3351	3351	{
3352	3352	var x: i32 = 1;
...	...	@@ -3377,7 +3377,7 @@ test "labeled break from labeled block expression" {
3377	3377
3378	3378	{#header_open\|Shadowing#}
3379	3379	<p>It is never allowed for an identifier to "hide" another one by using the same name:</p>
3380		{#code_begin\|test_err\|redefinition#}
	3380	{#code_begin\|test_err\|local shadows declaration#}
3381	3381	const pi = 3.14;
3382	3382
3383	3383	test "inside test block" {
...	...	@@ -4228,8 +4228,8 @@ test "type of unreachable" {
4228	4228	comptime {
4229	4229	// The type of unreachable is noreturn.
4230	4230
4231		// However this assertion will still fail because
4232		// evaluating unreachable at compile-time is a compile error.
	4231	// However this assertion will still fail to compile because
	4232	// unreachable expressions are compile errors.
4233	4233
4234	4234	assert(@TypeOf(unreachable) == noreturn);
4235	4235	}
...	...	@@ -5257,6 +5257,7 @@ test "float widening" {
5257	5257	// Compile time coercion of float to int
5258	5258	test "implicit cast to comptime_int" {
5259	5259	var f: f32 = 54.0 / 5;
	5260	_ = f;
5260	5261	}
5261	5262	{#code_end#}
5262	5263	{#header_close#}
...	...	@@ -5817,6 +5818,7 @@ fn foo(condition: bool) void {
5817	5818	if (condition) f32 else u64,
5818	5819	1234,
5819	5820	5678);
	5821	_ = result;
5820	5822	}
5821	5823	{#code_end#}
5822	5824	<p>
...	...	@@ -6313,7 +6315,7 @@ pub fn printValue(self: *Writer, value: anytype) !void {
6313	6315	<p>
6314	6316	And now, what happens if we give too many arguments to {#syntax#}printf{#endsyntax#}?
6315	6317	</p>
6316		{#code_begin\|test_err\|Unused argument in "here is a string: '{s}' here is a number: {}#}
	6318	{#code_begin\|test_err\|Unused argument in 'here is a string: '{s}' here is a number: {}#}
6317	6319	const print = @import("std").debug.print;
6318	6320
6319	6321	const a_number: i32 = 1234;
...	...	@@ -8853,6 +8855,7 @@ pub fn main() void {
8853	8855	comptime {
8854	8856	const array: [5]u8 = "hello".*;
8855	8857	const garbage = array[5];
	8858	_ = garbage;
8856	8859	}
8857	8860	{#code_end#}
8858	8861	<p>At runtime:</p>
...	...	@@ -8873,6 +8876,7 @@ fn foo(x: []const u8) u8 {
8873	8876	comptime {
8874	8877	const value: i32 = -1;
8875	8878	const unsigned = @intCast(u32, value);
	8879	_ = unsigned;
8876	8880	}
8877	8881	{#code_end#}
8878	8882	<p>At runtime:</p>
...	...	@@ -8895,6 +8899,7 @@ pub fn main() void {
8895	8899	comptime {
8896	8900	const spartan_count: u16 = 300;
8897	8901	const byte = @intCast(u8, spartan_count);
	8902	_ = byte;
8898	8903	}
8899	8904	{#code_end#}
8900	8905	<p>At runtime:</p>
...	...	@@ -9028,6 +9033,7 @@ test "wraparound addition and subtraction" {
9028	9033	{#code_begin\|test_err\|operation caused overflow#}
9029	9034	comptime {
9030	9035	const x = @shlExact(@as(u8, 0b01010101), 2);
	9036	_ = x;
9031	9037	}
9032	9038	{#code_end#}
9033	9039	<p>At runtime:</p>
...	...	@@ -9046,6 +9052,7 @@ pub fn main() void {
9046	9052	{#code_begin\|test_err\|exact shift shifted out 1 bits#}
9047	9053	comptime {
9048	9054	const x = @shrExact(@as(u8, 0b10101010), 2);
	9055	_ = x;
9049	9056	}
9050	9057	{#code_end#}
9051	9058	<p>At runtime:</p>
...	...	@@ -9066,6 +9073,7 @@ comptime {
9066	9073	const a: i32 = 1;
9067	9074	const b: i32 = 0;
9068	9075	const c = a / b;
	9076	_ = c;
9069	9077	}
9070	9078	{#code_end#}
9071	9079	<p>At runtime:</p>
...	...	@@ -9087,6 +9095,7 @@ comptime {
9087	9095	const a: i32 = 10;
9088	9096	const b: i32 = 0;
9089	9097	const c = a % b;
	9098	_ = c;
9090	9099	}
9091	9100	{#code_end#}
9092	9101	<p>At runtime:</p>
...	...	@@ -9108,6 +9117,7 @@ comptime {
9108	9117	const a: u32 = 10;
9109	9118	const b: u32 = 3;
9110	9119	const c = @divExact(a, b);
	9120	_ = c;
9111	9121	}
9112	9122	{#code_end#}
9113	9123	<p>At runtime:</p>
...	...	@@ -9300,6 +9310,7 @@ fn foo(set1: Set1) void {
9300	9310	comptime {
9301	9311	const ptr = @intToPtr(*align(1) i32, 0x1);
9302	9312	const aligned = @alignCast(4, ptr);
	9313	_ = aligned;
9303	9314	}
9304	9315	{#code_end#}
9305	9316	<p>At runtime:</p>
...	...	@@ -9414,6 +9425,7 @@ fn bar(f: *Foo) void {
9414	9425	comptime {
9415	9426	const opt_ptr: ?*i32 = null;
9416	9427	const ptr = @ptrCast(*i32, opt_ptr);
	9428	_ = ptr;
9417	9429	}
9418	9430	{#code_end#}
9419	9431	<p>At runtime:</p>

lib/std/fmt.zig+2-2

...	...	@@ -362,8 +362,8 @@ pub fn format(
362	362	const missing_count = arg_state.args_len - @popCount(ArgSetType, arg_state.used_args);
363	363	switch (missing_count) {
364	364	0 => unreachable,
365		1 => @compileError("Unused argument in \"" ++ fmt ++ "\""),
366		else => @compileError((comptime comptimePrint("{d}", .{missing_count})) ++ " unused arguments in \"" ++ fmt ++ "\""),
	365	1 => @compileError("Unused argument in '" ++ fmt ++ "'"),
	366	else => @compileError((comptime comptimePrint("{d}", .{missing_count})) ++ " unused arguments in '" ++ fmt ++ "'"),
367	367	}
368	368	}
369	369	}

lib/std/mem.zig+5-5

...	...	@@ -2297,14 +2297,14 @@ pub fn replaceOwned(comptime T: type, allocator: *Allocator, input: []const T, n
2297	2297	}
2298	2298
2299	2299	test "replaceOwned" {
2300		const allocator = std.heap.page_allocator;
	2300	const gpa = std.testing.allocator;
2301	2301
2302		const base_replace = replaceOwned(u8, allocator, "All your base are belong to us", "base", "Zig") catch unreachable;
2303		defer allocator.free(base_replace);
	2302	const base_replace = replaceOwned(u8, gpa, "All your base are belong to us", "base", "Zig") catch @panic("out of memory");
	2303	defer gpa.free(base_replace);
2304	2304	try testing.expect(eql(u8, base_replace, "All your Zig are belong to us"));
2305	2305
2306		const zen_replace = replaceOwned(u8, allocator, "Favor reading code over writing code.", " code", "") catch unreachable;
2307		defer allocator.free(zen_replace);
	2306	const zen_replace = replaceOwned(u8, gpa, "Favor reading code over writing code.", " code", "") catch @panic("out of memory");
	2307	defer gpa.free(zen_replace);
2308	2308	try testing.expect(eql(u8, zen_replace, "Favor reading over writing."));
2309	2309	}
2310	2310

lib/std/os/uefi/protocols/simple_network_protocol.zig+4-4

...	...	@@ -57,13 +57,13 @@ pub const SimpleNetworkProtocol = extern struct {
57	57	}
58	58
59	59	/// Modifies or resets the current station address, if supported.
60		pub fn stationAddress(self: const SimpleNetworkProtocol, reset: bool, new: ?const MacAddress) Status {
61		return self._station_address(self, reset, new);
	60	pub fn stationAddress(self: const SimpleNetworkProtocol, reset_flag: bool, new: ?const MacAddress) Status {
	61	return self._station_address(self, reset_flag, new);
62	62	}
63	63
64	64	/// Resets or collects the statistics on a network interface.
65		pub fn statistics(self: const SimpleNetworkProtocol, reset_: bool, statistics_size: ?usize, statistics_table: ?*NetworkStatistics) Status {
66		return self._statistics(self, reset_, statistics_size, statistics_table);
	65	pub fn statistics(self: const SimpleNetworkProtocol, reset_flag: bool, statistics_size: ?usize, statistics_table: ?*NetworkStatistics) Status {
	66	return self._statistics(self, reset_flag, statistics_size, statistics_table);
67	67	}
68	68
69	69	/// Converts a multicast IP address to a multicast HW MAC address.

lib/std/unicode.zig-1

...	...	@@ -247,7 +247,6 @@ pub const Utf8View = struct {
247	247	} else \|err\| switch (err) {
248	248	error.InvalidUtf8 => {
249	249	@compileError("invalid utf8");
250		unreachable;
251	250	},
252	251	}
253	252	}

lib/std/zig.zig+147-56

...	...	@@ -6,6 +6,7 @@
6	6	const std = @import("std.zig");
7	7	const tokenizer = @import("zig/tokenizer.zig");
8	8	const fmt = @import("zig/fmt.zig");
	9	const assert = std.debug.assert;
9	10
10	11	pub const Token = tokenizer.Token;
11	12	pub const Tokenizer = tokenizer.Tokenizer;
...	...	@@ -183,29 +184,48 @@ pub fn binNameAlloc(allocator: *std.mem.Allocator, options: BinNameOptions) erro
183	184	}
184	185	}
185	186
	187	pub const ParsedCharLiteral = union(enum) {
	188	success: u32,
	189	/// The character after backslash is not recognized.
	190	invalid_escape_character: usize,
	191	/// Expected hex digit at this index.
	192	expected_hex_digit: usize,
	193	/// Unicode escape sequence had no digits with rbrace at this index.
	194	empty_unicode_escape_sequence: usize,
	195	/// Expected hex digit or '}' at this index.
	196	expected_hex_digit_or_rbrace: usize,
	197	/// The unicode point is outside the range of Unicode codepoints.
	198	unicode_escape_overflow: usize,
	199	/// Expected '{' at this index.
	200	expected_lbrace: usize,
	201	/// Expected the terminating single quote at this index.
	202	expected_end: usize,
	203	/// The character at this index cannot be represented without an escape sequence.
	204	invalid_character: usize,
	205	};
	206
186	207	/// Only validates escape sequence characters.
187	208	/// Slice must be valid utf8 starting and ending with "'" and exactly one codepoint in between.
188		pub fn parseCharLiteral(
189		slice: []const u8,
190		bad_index: *usize, // populated if error.InvalidCharacter is returned
191		) error{InvalidCharacter}!u32 {
192		std.debug.assert(slice.len >= 3 and slice[0] == '\'' and slice[slice.len - 1] == '\'');
	209	pub fn parseCharLiteral(slice: []const u8) ParsedCharLiteral {
	210	assert(slice.len >= 3 and slice[0] == '\'' and slice[slice.len - 1] == '\'');
193	211
194		if (slice[1] == '\\') {
195		switch (slice[2]) {
196		'n' => return '\n',
197		'r' => return '\r',
198		'\\' => return '\\',
199		't' => return '\t',
200		'\'' => return '\'',
201		'"' => return '"',
	212	switch (slice[1]) {
	213	0 => return .{ .invalid_character = 1 },
	214	'\\' => switch (slice[2]) {
	215	'n' => return .{ .success = '\n' },
	216	'r' => return .{ .success = '\r' },
	217	'\\' => return .{ .success = '\\' },
	218	't' => return .{ .success = '\t' },
	219	'\'' => return .{ .success = '\'' },
	220	'"' => return .{ .success = '"' },
202	221	'x' => {
203		if (slice.len != 6) {
204		bad_index.* = slice.len - 2;
205		return error.InvalidCharacter;
	222	if (slice.len < 4) {
	223	return .{ .expected_hex_digit = 3 };
206	224	}
207	225	var value: u32 = 0;
208		for (slice[3..5]) \|c, i\| {
	226	var i: usize = 3;
	227	while (i < 5) : (i += 1) {
	228	const c = slice[i];
209	229	switch (c) {
210	230	'0'...'9' => {
211	231	value *= 16;
...	...	@@ -220,20 +240,28 @@ pub fn parseCharLiteral(
220	240	value += c - 'A' + 10;
221	241	},
222	242	else => {
223		bad_index.* = 3 + i;
224		return error.InvalidCharacter;
	243	return .{ .expected_hex_digit = i };
225	244	},
226	245	}
227	246	}
228		return value;
	247	if (slice[i] != '\'') {
	248	return .{ .expected_end = i };
	249	}
	250	return .{ .success = value };
229	251	},
230	252	'u' => {
231		if (slice.len < "'\\u{0}'".len or slice[3] != '{' or slice[slice.len - 2] != '}') {
232		bad_index.* = 2;
233		return error.InvalidCharacter;
	253	var i: usize = 3;
	254	if (slice[i] != '{') {
	255	return .{ .expected_lbrace = i };
234	256	}
	257	i += 1;
	258	if (slice[i] == '}') {
	259	return .{ .empty_unicode_escape_sequence = i };
	260	}
	261
235	262	var value: u32 = 0;
236		for (slice[4 .. slice.len - 2]) \|c, i\| {
	263	while (i < slice.len) : (i += 1) {
	264	const c = slice[i];
237	265	switch (c) {
238	266	'0'...'9' => {
239	267	value *= 16;
...	...	@@ -247,49 +275,112 @@ pub fn parseCharLiteral(
247	275	value *= 16;
248	276	value += c - 'A' + 10;
249	277	},
250		else => {
251		bad_index.* = 4 + i;
252		return error.InvalidCharacter;
	278	'}' => {
	279	i += 1;
	280	break;
253	281	},
	282	else => return .{ .expected_hex_digit_or_rbrace = i },
254	283	}
255	284	if (value > 0x10ffff) {
256		bad_index.* = 4 + i;
257		return error.InvalidCharacter;
	285	return .{ .unicode_escape_overflow = i };
258	286	}
259	287	}
260		return value;
261		},
262		else => {
263		bad_index.* = 2;
264		return error.InvalidCharacter;
	288	if (slice[i] != '\'') {
	289	return .{ .expected_end = i };
	290	}
	291	return .{ .success = value };
265	292	},
266		}
	293	else => return .{ .invalid_escape_character = 2 },
	294	},
	295	else => {
	296	const codepoint = std.unicode.utf8Decode(slice[1 .. slice.len - 1]) catch unreachable;
	297	return .{ .success = codepoint };
	298	},
267	299	}
268		return std.unicode.utf8Decode(slice[1 .. slice.len - 1]) catch unreachable;
269	300	}
270	301
271	302	test "parseCharLiteral" {
272		var bad_index: usize = undefined;
273		try std.testing.expectEqual(try parseCharLiteral("'a'", &bad_index), 'a');
274		try std.testing.expectEqual(try parseCharLiteral("'ä'", &bad_index), 'ä');
275		try std.testing.expectEqual(try parseCharLiteral("'\\x00'", &bad_index), 0);
276		try std.testing.expectEqual(try parseCharLiteral("'\\x4f'", &bad_index), 0x4f);
277		try std.testing.expectEqual(try parseCharLiteral("'\\x4F'", &bad_index), 0x4f);
278		try std.testing.expectEqual(try parseCharLiteral("'ぁ'", &bad_index), 0x3041);
279		try std.testing.expectEqual(try parseCharLiteral("'\\u{0}'", &bad_index), 0);
280		try std.testing.expectEqual(try parseCharLiteral("'\\u{3041}'", &bad_index), 0x3041);
281		try std.testing.expectEqual(try parseCharLiteral("'\\u{7f}'", &bad_index), 0x7f);
282		try std.testing.expectEqual(try parseCharLiteral("'\\u{7FFF}'", &bad_index), 0x7FFF);
	303	try std.testing.expectEqual(
	304	ParsedCharLiteral{ .success = 'a' },
	305	parseCharLiteral("'a'"),
	306	);
	307	try std.testing.expectEqual(
	308	ParsedCharLiteral{ .success = 'ä' },
	309	parseCharLiteral("'ä'"),
	310	);
	311	try std.testing.expectEqual(
	312	ParsedCharLiteral{ .success = 0 },
	313	parseCharLiteral("'\\x00'"),
	314	);
	315	try std.testing.expectEqual(
	316	ParsedCharLiteral{ .success = 0x4f },
	317	parseCharLiteral("'\\x4f'"),
	318	);
	319	try std.testing.expectEqual(
	320	ParsedCharLiteral{ .success = 0x4f },
	321	parseCharLiteral("'\\x4F'"),
	322	);
	323	try std.testing.expectEqual(
	324	ParsedCharLiteral{ .success = 0x3041 },
	325	parseCharLiteral("'ぁ'"),
	326	);
	327	try std.testing.expectEqual(
	328	ParsedCharLiteral{ .success = 0 },
	329	parseCharLiteral("'\\u{0}'"),
	330	);
	331	try std.testing.expectEqual(
	332	ParsedCharLiteral{ .success = 0x3041 },
	333	parseCharLiteral("'\\u{3041}'"),
	334	);
	335	try std.testing.expectEqual(
	336	ParsedCharLiteral{ .success = 0x7f },
	337	parseCharLiteral("'\\u{7f}'"),
	338	);
	339	try std.testing.expectEqual(
	340	ParsedCharLiteral{ .success = 0x7fff },
	341	parseCharLiteral("'\\u{7FFF}'"),
	342	);
283	343
284		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x0'", &bad_index));
285		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x000'", &bad_index));
286		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\y'", &bad_index));
287		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u'", &bad_index));
288		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\uFFFF'", &bad_index));
289		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{}'", &bad_index));
290		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFFFF}'", &bad_index));
291		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF'", &bad_index));
292		try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF}x'", &bad_index));
	344	try std.testing.expectEqual(
	345	ParsedCharLiteral{ .expected_hex_digit = 4 },
	346	parseCharLiteral("'\\x0'"),
	347	);
	348	try std.testing.expectEqual(
	349	ParsedCharLiteral{ .expected_end = 5 },
	350	parseCharLiteral("'\\x000'"),
	351	);
	352	try std.testing.expectEqual(
	353	ParsedCharLiteral{ .invalid_escape_character = 2 },
	354	parseCharLiteral("'\\y'"),
	355	);
	356	try std.testing.expectEqual(
	357	ParsedCharLiteral{ .expected_lbrace = 3 },
	358	parseCharLiteral("'\\u'"),
	359	);
	360	try std.testing.expectEqual(
	361	ParsedCharLiteral{ .expected_lbrace = 3 },
	362	parseCharLiteral("'\\uFFFF'"),
	363	);
	364	try std.testing.expectEqual(
	365	ParsedCharLiteral{ .empty_unicode_escape_sequence = 4 },
	366	parseCharLiteral("'\\u{}'"),
	367	);
	368	try std.testing.expectEqual(
	369	ParsedCharLiteral{ .unicode_escape_overflow = 9 },
	370	parseCharLiteral("'\\u{FFFFFF}'"),
	371	);
	372	try std.testing.expectEqual(
	373	ParsedCharLiteral{ .expected_hex_digit_or_rbrace = 8 },
	374	parseCharLiteral("'\\u{FFFF'"),
	375	);
	376	try std.testing.expectEqual(
	377	ParsedCharLiteral{ .expected_end = 9 },
	378	parseCharLiteral("'\\u{FFFF}x'"),
	379	);
	380	try std.testing.expectEqual(
	381	ParsedCharLiteral{ .invalid_character = 1 },
	382	parseCharLiteral("'\x00'"),
	383	);
293	384	}
294	385
295	386	test {

lib/std/zig/ast.zig+4-2

...	...	@@ -20,7 +20,7 @@ pub const NodeList = std.MultiArrayList(Node);
20	20
21	21	pub const Tree = struct {
22	22	/// Reference to externally-owned data.
23		source: []const u8,
	23	source: [:0]const u8,
24	24
25	25	tokens: TokenList.Slice,
26	26	/// The root AST node is assumed to be index 0. Since there can be no
...	...	@@ -135,6 +135,8 @@ pub const Tree = struct {
135	135	const token_tags = tree.tokens.items(.tag);
136	136	switch (parse_error.tag) {
137	137	.asterisk_after_ptr_deref => {
	138	// Note that the token will point at the `.*` but ideally the source
	139	// location would point to the `` after the `.`.
138	140	return stream.writeAll("'.' cannot be followed by ''. Are you missing a space?");
139	141	},
140	142	.decl_between_fields => {
...	...	@@ -284,7 +286,7 @@ pub const Tree = struct {
284	286	return stream.writeAll("bit range not allowed on slices and arrays");
285	287	},
286	288	.invalid_token => {
287		return stream.print("invalid token '{s}'", .{
	289	return stream.print("invalid token: '{s}'", .{
288	290	token_tags[parse_error.token].symbol(),
289	291	});
290	292	},

lib/std/zig/parse.zig+1-1

...	...	@@ -17,7 +17,7 @@ pub const Error = error{ParseError} \|\| Allocator.Error;
17	17
18	18	/// Result should be freed with tree.deinit() when there are
19	19	/// no more references to any of the tokens or nodes.
20		pub fn parse(gpa: *Allocator, source: []const u8) Allocator.Error!Tree {
	20	pub fn parse(gpa: *Allocator, source: [:0]const u8) Allocator.Error!Tree {
21	21	var tokens = ast.TokenList{};
22	22	defer tokens.deinit(gpa);
23	23

lib/std/zig/parser_test.zig+4-4

...	...	@@ -5194,7 +5194,7 @@ const maxInt = std.math.maxInt;
5194	5194
5195	5195	var fixed_buffer_mem: [100 * 1024]u8 = undefined;
5196	5196
5197		fn testParse(source: []const u8, allocator: mem.Allocator, anything_changed: bool) ![]u8 {
	5197	fn testParse(source: [:0]const u8, allocator: mem.Allocator, anything_changed: bool) ![]u8 {
5198	5198	const stderr = io.getStdErr().writer();
5199	5199
5200	5200	var tree = try std.zig.parse(allocator, source);
...	...	@@ -5222,7 +5222,7 @@ fn testParse(source: []const u8, allocator: mem.Allocator, anything_changed: b
5222	5222	anything_changed.* = !mem.eql(u8, formatted, source);
5223	5223	return formatted;
5224	5224	}
5225		fn testTransform(source: []const u8, expected_source: []const u8) !void {
	5225	fn testTransform(source: [:0]const u8, expected_source: []const u8) !void {
5226	5226	const needed_alloc_count = x: {
5227	5227	// Try it once with unlimited memory, make sure it works
5228	5228	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
...	...	@@ -5268,13 +5268,13 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {
5268	5268	}
5269	5269	}
5270	5270	}
5271		fn testCanonical(source: []const u8) !void {
	5271	fn testCanonical(source: [:0]const u8) !void {
5272	5272	return testTransform(source, source);
5273	5273	}
5274	5274
5275	5275	const Error = std.zig.ast.Error.Tag;
5276	5276
5277		fn testError(source: []const u8, expected_errors: []const Error) !void {
	5277	fn testError(source: [:0]const u8, expected_errors: []const Error) !void {
5278	5278	var tree = try std.zig.parse(std.testing.allocator, source);
5279	5279	defer tree.deinit(std.testing.allocator);
5280	5280

lib/std/zig/tokenizer.zig+78-189

...	...	@@ -326,7 +326,7 @@ pub const Token = struct {
326	326	};
327	327
328	328	pub const Tokenizer = struct {
329		buffer: []const u8,
	329	buffer: [:0]const u8,
330	330	index: usize,
331	331	pending_invalid_token: ?Token,
332	332
...	...	@@ -335,7 +335,7 @@ pub const Tokenizer = struct {
335	335	std.debug.warn("{s} \"{s}\"\n", .{ @tagName(token.tag), self.buffer[token.start..token.end] });
336	336	}
337	337
338		pub fn init(buffer: []const u8) Tokenizer {
	338	pub fn init(buffer: [:0]const u8) Tokenizer {
339	339	// Skip the UTF-8 BOM if present
340	340	const src_start = if (mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else @as(usize, 0);
341	341	return Tokenizer{
...	...	@@ -373,7 +373,6 @@ pub const Tokenizer = struct {
373	373	line_comment,
374	374	doc_comment_start,
375	375	doc_comment,
376		container_doc_comment,
377	376	zero,
378	377	int_literal_dec,
379	378	int_literal_dec_no_underscore,
...	...	@@ -407,10 +406,6 @@ pub const Tokenizer = struct {
407	406	saw_at_sign,
408	407	};
409	408
410		fn isIdentifierChar(char: u8) bool {
411		return std.ascii.isAlNum(char) or char == '_';
412		}
413
414	409	pub fn next(self: *Tokenizer) Token {
415	410	if (self.pending_invalid_token) \|token\| {
416	411	self.pending_invalid_token = null;
...	...	@@ -426,10 +421,11 @@ pub const Tokenizer = struct {
426	421	};
427	422	var seen_escape_digits: usize = undefined;
428	423	var remaining_code_units: usize = undefined;
429		while (self.index < self.buffer.len) : (self.index += 1) {
	424	while (true) : (self.index += 1) {
430	425	const c = self.buffer[self.index];
431	426	switch (state) {
432	427	.start => switch (c) {
	428	0 => break,
433	429	' ', '\n', '\t', '\r' => {
434	430	result.loc.start = self.index + 1;
435	431	},
...	...	@@ -555,8 +551,9 @@ pub const Tokenizer = struct {
555	551	},
556	552	else => {
557	553	result.tag = .invalid;
	554	result.loc.end = self.index;
558	555	self.index += 1;
559		break;
	556	return result;
560	557	},
561	558	},
562	559
...	...	@@ -705,18 +702,35 @@ pub const Tokenizer = struct {
705	702	self.index += 1;
706	703	break;
707	704	},
708		'\n', '\r' => break, // Look for this error later.
	705	0 => {
	706	if (self.index == self.buffer.len) {
	707	break;
	708	} else {
	709	self.checkLiteralCharacter();
	710	}
	711	},
	712	'\n' => {
	713	result.tag = .invalid;
	714	break;
	715	},
709	716	else => self.checkLiteralCharacter(),
710	717	},
711	718
712	719	.string_literal_backslash => switch (c) {
713		'\n', '\r' => break, // Look for this error later.
	720	'\n' => {
	721	result.tag = .invalid;
	722	break;
	723	},
714	724	else => {
715	725	state = .string_literal;
716	726	},
717	727	},
718	728
719	729	.char_literal => switch (c) {
	730	0 => {
	731	result.tag = .invalid;
	732	break;
	733	},
720	734	'\\' => {
721	735	state = .char_literal_backslash;
722	736	},
...	...	@@ -742,7 +756,7 @@ pub const Tokenizer = struct {
742	756	},
743	757
744	758	.char_literal_backslash => switch (c) {
745		'\n' => {
	759	0, '\n' => {
746	760	result.tag = .invalid;
747	761	break;
748	762	},
...	...	@@ -774,7 +788,6 @@ pub const Tokenizer = struct {
774	788	.char_literal_unicode_escape_saw_u => switch (c) {
775	789	'{' => {
776	790	state = .char_literal_unicode_escape;
777		seen_escape_digits = 0;
778	791	},
779	792	else => {
780	793	result.tag = .invalid;
...	...	@@ -783,16 +796,9 @@ pub const Tokenizer = struct {
783	796	},
784	797
785	798	.char_literal_unicode_escape => switch (c) {
786		'0'...'9', 'a'...'f', 'A'...'F' => {
787		seen_escape_digits += 1;
788		},
	799	'0'...'9', 'a'...'f', 'A'...'F' => {},
789	800	'}' => {
790		if (seen_escape_digits == 0) {
791		result.tag = .invalid;
792		state = .char_literal_unicode_invalid;
793		} else {
794		state = .char_literal_end;
795		}
	801	state = .char_literal_end; // too many/few digits handled later
796	802	},
797	803	else => {
798	804	result.tag = .invalid;
...	...	@@ -834,6 +840,7 @@ pub const Tokenizer = struct {
834	840	},
835	841
836	842	.multiline_string_literal_line => switch (c) {
	843	0 => break,
837	844	'\n' => {
838	845	self.index += 1;
839	846	break;
...	...	@@ -1025,12 +1032,19 @@ pub const Tokenizer = struct {
1025	1032	},
1026	1033	},
1027	1034	.line_comment_start => switch (c) {
	1035	0 => {
	1036	if (self.index != self.buffer.len) {
	1037	result.tag = .invalid;
	1038	self.index += 1;
	1039	}
	1040	break;
	1041	},
1028	1042	'/' => {
1029	1043	state = .doc_comment_start;
1030	1044	},
1031	1045	'!' => {
1032	1046	result.tag = .container_doc_comment;
1033		state = .container_doc_comment;
	1047	state = .doc_comment;
1034	1048	},
1035	1049	'\n' => {
1036	1050	state = .start;
...	...	@@ -1046,7 +1060,7 @@ pub const Tokenizer = struct {
1046	1060	'/' => {
1047	1061	state = .line_comment;
1048	1062	},
1049		'\n' => {
	1063	0, '\n' => {
1050	1064	result.tag = .doc_comment;
1051	1065	break;
1052	1066	},
...	...	@@ -1061,6 +1075,7 @@ pub const Tokenizer = struct {
1061	1075	},
1062	1076	},
1063	1077	.line_comment => switch (c) {
	1078	0 => break,
1064	1079	'\n' => {
1065	1080	state = .start;
1066	1081	result.loc.start = self.index + 1;
...	...	@@ -1068,8 +1083,8 @@ pub const Tokenizer = struct {
1068	1083	'\t', '\r' => {},
1069	1084	else => self.checkLiteralCharacter(),
1070	1085	},
1071		.doc_comment, .container_doc_comment => switch (c) {
1072		'\n' => break,
	1086	.doc_comment => switch (c) {
	1087	0, '\n' => break,
1073	1088	'\t', '\r' => {},
1074	1089	else => self.checkLiteralCharacter(),
1075	1090	},
...	...	@@ -1088,12 +1103,11 @@ pub const Tokenizer = struct {
1088	1103	self.index -= 1;
1089	1104	state = .int_literal_dec;
1090	1105	},
1091		else => {
1092		if (isIdentifierChar(c)) {
1093		result.tag = .invalid;
1094		}
	1106	'a', 'c', 'd', 'f'...'n', 'p'...'w', 'y', 'z', 'A'...'D', 'F'...'Z' => {
	1107	result.tag = .invalid;
1095	1108	break;
1096	1109	},
	1110	else => break,
1097	1111	},
1098	1112	.int_literal_bin_no_underscore => switch (c) {
1099	1113	'0'...'1' => {
...	...	@@ -1109,12 +1123,11 @@ pub const Tokenizer = struct {
1109	1123	state = .int_literal_bin_no_underscore;
1110	1124	},
1111	1125	'0'...'1' => {},
1112		else => {
1113		if (isIdentifierChar(c)) {
1114		result.tag = .invalid;
1115		}
	1126	'2'...'9', 'a'...'z', 'A'...'Z' => {
	1127	result.tag = .invalid;
1116	1128	break;
1117	1129	},
	1130	else => break,
1118	1131	},
1119	1132	.int_literal_oct_no_underscore => switch (c) {
1120	1133	'0'...'7' => {
...	...	@@ -1130,12 +1143,11 @@ pub const Tokenizer = struct {
1130	1143	state = .int_literal_oct_no_underscore;
1131	1144	},
1132	1145	'0'...'7' => {},
1133		else => {
1134		if (isIdentifierChar(c)) {
1135		result.tag = .invalid;
1136		}
	1146	'8', '9', 'a'...'z', 'A'...'Z' => {
	1147	result.tag = .invalid;
1137	1148	break;
1138	1149	},
	1150	else => break,
1139	1151	},
1140	1152	.int_literal_dec_no_underscore => switch (c) {
1141	1153	'0'...'9' => {
...	...	@@ -1159,12 +1171,11 @@ pub const Tokenizer = struct {
1159	1171	result.tag = .float_literal;
1160	1172	},
1161	1173	'0'...'9' => {},
1162		else => {
1163		if (isIdentifierChar(c)) {
1164		result.tag = .invalid;
1165		}
	1174	'a'...'d', 'f'...'z', 'A'...'D', 'F'...'Z' => {
	1175	result.tag = .invalid;
1166	1176	break;
1167	1177	},
	1178	else => break,
1168	1179	},
1169	1180	.int_literal_hex_no_underscore => switch (c) {
1170	1181	'0'...'9', 'a'...'f', 'A'...'F' => {
...	...	@@ -1188,12 +1199,11 @@ pub const Tokenizer = struct {
1188	1199	result.tag = .float_literal;
1189	1200	},
1190	1201	'0'...'9', 'a'...'f', 'A'...'F' => {},
1191		else => {
1192		if (isIdentifierChar(c)) {
1193		result.tag = .invalid;
1194		}
	1202	'g'...'o', 'q'...'z', 'G'...'O', 'Q'...'Z' => {
	1203	result.tag = .invalid;
1195	1204	break;
1196	1205	},
	1206	else => break,
1197	1207	},
1198	1208	.num_dot_dec => switch (c) {
1199	1209	'.' => {
...	...	@@ -1206,12 +1216,11 @@ pub const Tokenizer = struct {
1206	1216	result.tag = .float_literal;
1207	1217	state = .float_fraction_dec;
1208	1218	},
1209		else => {
1210		if (isIdentifierChar(c)) {
1211		result.tag = .invalid;
1212		}
	1219	'_', 'a'...'z', 'A'...'Z' => {
	1220	result.tag = .invalid;
1213	1221	break;
1214	1222	},
	1223	else => break,
1215	1224	},
1216	1225	.num_dot_hex => switch (c) {
1217	1226	'.' => {
...	...	@@ -1224,12 +1233,11 @@ pub const Tokenizer = struct {
1224	1233	result.tag = .float_literal;
1225	1234	state = .float_fraction_hex;
1226	1235	},
1227		else => {
1228		if (isIdentifierChar(c)) {
1229		result.tag = .invalid;
1230		}
	1236	'_', 'g'...'z', 'G'...'Z' => {
	1237	result.tag = .invalid;
1231	1238	break;
1232	1239	},
	1240	else => break,
1233	1241	},
1234	1242	.float_fraction_dec_no_underscore => switch (c) {
1235	1243	'0'...'9' => {
...	...	@@ -1248,12 +1256,11 @@ pub const Tokenizer = struct {
1248	1256	state = .float_exponent_unsigned;
1249	1257	},
1250	1258	'0'...'9' => {},
1251		else => {
1252		if (isIdentifierChar(c)) {
1253		result.tag = .invalid;
1254		}
	1259	'a'...'d', 'f'...'z', 'A'...'D', 'F'...'Z' => {
	1260	result.tag = .invalid;
1255	1261	break;
1256	1262	},
	1263	else => break,
1257	1264	},
1258	1265	.float_fraction_hex_no_underscore => switch (c) {
1259	1266	'0'...'9', 'a'...'f', 'A'...'F' => {
...	...	@@ -1272,12 +1279,11 @@ pub const Tokenizer = struct {
1272	1279	state = .float_exponent_unsigned;
1273	1280	},
1274	1281	'0'...'9', 'a'...'f', 'A'...'F' => {},
1275		else => {
1276		if (isIdentifierChar(c)) {
1277		result.tag = .invalid;
1278		}
	1282	'g'...'o', 'q'...'z', 'G'...'O', 'Q'...'Z' => {
	1283	result.tag = .invalid;
1279	1284	break;
1280	1285	},
	1286	else => break,
1281	1287	},
1282	1288	.float_exponent_unsigned => switch (c) {
1283	1289	'+', '-' => {
...	...	@@ -1303,130 +1309,11 @@ pub const Tokenizer = struct {
1303	1309	state = .float_exponent_num_no_underscore;
1304	1310	},
1305	1311	'0'...'9' => {},
1306		else => {
1307		if (isIdentifierChar(c)) {
1308		result.tag = .invalid;
1309		}
	1312	'a'...'z', 'A'...'Z' => {
	1313	result.tag = .invalid;
1310	1314	break;
1311	1315	},
1312		},
1313		}
1314		} else if (self.index == self.buffer.len) {
1315		switch (state) {
1316		.start,
1317		.int_literal_dec,
1318		.int_literal_bin,
1319		.int_literal_oct,
1320		.int_literal_hex,
1321		.num_dot_dec,
1322		.num_dot_hex,
1323		.float_fraction_dec,
1324		.float_fraction_hex,
1325		.float_exponent_num,
1326		.string_literal, // find this error later
1327		.multiline_string_literal_line,
1328		.builtin,
1329		.line_comment,
1330		.line_comment_start,
1331		=> {},
1332
1333		.identifier => {
1334		if (Token.getKeyword(self.buffer[result.loc.start..self.index])) \|tag\| {
1335		result.tag = tag;
1336		}
1337		},
1338		.doc_comment, .doc_comment_start => {
1339		result.tag = .doc_comment;
1340		},
1341		.container_doc_comment => {
1342		result.tag = .container_doc_comment;
1343		},
1344
1345		.int_literal_dec_no_underscore,
1346		.int_literal_bin_no_underscore,
1347		.int_literal_oct_no_underscore,
1348		.int_literal_hex_no_underscore,
1349		.float_fraction_dec_no_underscore,
1350		.float_fraction_hex_no_underscore,
1351		.float_exponent_num_no_underscore,
1352		.float_exponent_unsigned,
1353		.saw_at_sign,
1354		.backslash,
1355		.char_literal,
1356		.char_literal_backslash,
1357		.char_literal_hex_escape,
1358		.char_literal_unicode_escape_saw_u,
1359		.char_literal_unicode_escape,
1360		.char_literal_unicode_invalid,
1361		.char_literal_end,
1362		.char_literal_unicode,
1363		.string_literal_backslash,
1364		=> {
1365		result.tag = .invalid;
1366		},
1367
1368		.equal => {
1369		result.tag = .equal;
1370		},
1371		.bang => {
1372		result.tag = .bang;
1373		},
1374		.minus => {
1375		result.tag = .minus;
1376		},
1377		.slash => {
1378		result.tag = .slash;
1379		},
1380		.zero => {
1381		result.tag = .integer_literal;
1382		},
1383		.ampersand => {
1384		result.tag = .ampersand;
1385		},
1386		.period => {
1387		result.tag = .period;
1388		},
1389		.period_2 => {
1390		result.tag = .ellipsis2;
1391		},
1392		.period_asterisk => {
1393		result.tag = .period_asterisk;
1394		},
1395		.pipe => {
1396		result.tag = .pipe;
1397		},
1398		.angle_bracket_angle_bracket_right => {
1399		result.tag = .angle_bracket_angle_bracket_right;
1400		},
1401		.angle_bracket_right => {
1402		result.tag = .angle_bracket_right;
1403		},
1404		.angle_bracket_angle_bracket_left => {
1405		result.tag = .angle_bracket_angle_bracket_left;
1406		},
1407		.angle_bracket_left => {
1408		result.tag = .angle_bracket_left;
1409		},
1410		.plus_percent => {
1411		result.tag = .plus_percent;
1412		},
1413		.plus => {
1414		result.tag = .plus;
1415		},
1416		.percent => {
1417		result.tag = .percent;
1418		},
1419		.caret => {
1420		result.tag = .caret;
1421		},
1422		.asterisk_percent => {
1423		result.tag = .asterisk_percent;
1424		},
1425		.asterisk => {
1426		result.tag = .asterisk;
1427		},
1428		.minus_percent => {
1429		result.tag = .minus_percent;
	1316	else => break,
1430	1317	},
1431	1318	}
1432	1319	}
...	...	@@ -1566,7 +1453,7 @@ test "tokenizer - code point literal with unicode escapes" {
1566	1453	, &.{ .invalid, .invalid });
1567	1454	try testTokenize(
1568	1455	\\'\u{}'
1569		, &.{ .invalid, .invalid });
	1456	, &.{.char_literal});
1570	1457	try testTokenize(
1571	1458	\\'\u{s}'
1572	1459	, &.{ .invalid, .invalid });
...	...	@@ -2049,15 +1936,17 @@ test "tokenizer - invalid builtin identifiers" {
2049	1936	try testTokenize("@0()", &.{ .invalid, .integer_literal, .l_paren, .r_paren });
2050	1937	}
2051	1938
2052		fn testTokenize(source: []const u8, expected_tokens: []const Token.Tag) !void {
	1939	fn testTokenize(source: [:0]const u8, expected_tokens: []const Token.Tag) !void {
2053	1940	var tokenizer = Tokenizer.init(source);
2054	1941	for (expected_tokens) \|expected_token_id\| {
2055	1942	const token = tokenizer.next();
2056	1943	if (token.tag != expected_token_id) {
2057		std.debug.panic("expected {s}, found {s}\n", .{ @tagName(expected_token_id), @tagName(token.tag) });
	1944	std.debug.panic("expected {s}, found {s}\n", .{
	1945	@tagName(expected_token_id), @tagName(token.tag),
	1946	});
2058	1947	}
2059	1948	}
2060	1949	const last_token = tokenizer.next();
2061		try std.testing.expect(last_token.tag == .eof);
2062		try std.testing.expect(last_token.loc.start == source.len);
	1950	try std.testing.expectEqual(Token.Tag.eof, last_token.tag);
	1951	try std.testing.expectEqual(source.len, last_token.loc.start);
2063	1952	}

src/AstGen.zig+321-180

...	...	@@ -34,8 +34,9 @@ string_table: std.StringHashMapUnmanaged(u32) = .{},
34	34	compile_errors: ArrayListUnmanaged(Zir.Inst.CompileErrors.Item) = .{},
35	35	/// The topmost block of the current function.
36	36	fn_block: ?*GenZir = null,
37		/// String table indexes, keeps track of all `@import` operands.
38		imports: std.AutoArrayHashMapUnmanaged(u32, void) = .{},
	37	/// Maps string table indexes to the first `@import` ZIR instruction
	38	/// that uses this string as the operand.
	39	imports: std.AutoArrayHashMapUnmanaged(u32, Zir.Inst.Index) = .{},
39	40
40	41	const InnerError = error{ OutOfMemory, AnalysisFail };
41	42
...	...	@@ -154,7 +155,7 @@ pub fn generate(gpa: *Allocator, tree: ast.Tree) Allocator.Error!Zir {
154	155	astgen.extra.items[imports_index] = astgen.addExtraAssumeCapacity(Zir.Inst.Imports{
155	156	.imports_len = @intCast(u32, astgen.imports.count()),
156	157	});
157		astgen.extra.appendSliceAssumeCapacity(astgen.imports.keys());
	158	astgen.extra.appendSliceAssumeCapacity(astgen.imports.values());
158	159	}
159	160
160	161	return Zir{
...	...	@@ -261,6 +262,23 @@ fn typeExpr(gz: GenZir, scope: Scope, type_node: ast.Node.Index) InnerError!Zi
261	262	return expr(gz, scope, .{ .ty = .type_type }, type_node);
262	263	}
263	264
	265	/// Same as `expr` but fails with a compile error if the result type is `noreturn`.
	266	fn reachableExpr(
	267	gz: *GenZir,
	268	scope: *Scope,
	269	rl: ResultLoc,
	270	node: ast.Node.Index,
	271	src_node: ast.Node.Index,
	272	) InnerError!Zir.Inst.Ref {
	273	const result_inst = try expr(gz, scope, rl, node);
	274	if (gz.refIsNoReturn(result_inst)) {
	275	return gz.astgen.failNodeNotes(src_node, "unreachable code", .{}, &[_]u32{
	276	try gz.astgen.errNoteNode(node, "control flow is diverted here", .{}),
	277	});
	278	}
	279	return result_inst;
	280	}
	281
264	282	fn lvalExpr(gz: GenZir, scope: Scope, node: ast.Node.Index) InnerError!Zir.Inst.Ref {
265	283	const astgen = gz.astgen;
266	284	const tree = astgen.tree;
...	...	@@ -1296,22 +1314,23 @@ fn structInitExpr(
1296	1314	const astgen = gz.astgen;
1297	1315	const tree = astgen.tree;
1298	1316
1299		if (struct_init.ast.fields.len == 0) {
1300		if (struct_init.ast.type_expr == 0) {
	1317	if (struct_init.ast.type_expr == 0) {
	1318	if (struct_init.ast.fields.len == 0) {
1301	1319	return rvalue(gz, rl, .empty_struct, node);
1302	1320	}
1303		array: {
1304		const node_tags = tree.nodes.items(.tag);
1305		const main_tokens = tree.nodes.items(.main_token);
1306		const array_type: ast.full.ArrayType = switch (node_tags[struct_init.ast.type_expr]) {
1307		.array_type => tree.arrayType(struct_init.ast.type_expr),
1308		.array_type_sentinel => tree.arrayTypeSentinel(struct_init.ast.type_expr),
1309		else => break :array,
1310		};
	1321	} else array: {
	1322	const node_tags = tree.nodes.items(.tag);
	1323	const main_tokens = tree.nodes.items(.main_token);
	1324	const array_type: ast.full.ArrayType = switch (node_tags[struct_init.ast.type_expr]) {
	1325	.array_type => tree.arrayType(struct_init.ast.type_expr),
	1326	.array_type_sentinel => tree.arrayTypeSentinel(struct_init.ast.type_expr),
	1327	else => break :array,
	1328	};
	1329	const is_inferred_array_len = node_tags[array_type.ast.elem_count] == .identifier and
1311	1330	// This intentionally does not support `@"_"` syntax.
1312		if (node_tags[array_type.ast.elem_count] == .identifier and
1313		mem.eql(u8, tree.tokenSlice(main_tokens[array_type.ast.elem_count]), "_"))
1314		{
	1331	mem.eql(u8, tree.tokenSlice(main_tokens[array_type.ast.elem_count]), "_");
	1332	if (struct_init.ast.fields.len == 0) {
	1333	if (is_inferred_array_len) {
1315	1334	const elem_type = try typeExpr(gz, scope, array_type.ast.elem_type);
1316	1335	const array_type_inst = if (array_type.ast.sentinel == 0) blk: {
1317	1336	break :blk try gz.addBin(.array_type, .zero_usize, elem_type);
...	...	@@ -1322,11 +1341,18 @@ fn structInitExpr(
1322	1341	const result = try gz.addUnNode(.struct_init_empty, array_type_inst, node);
1323	1342	return rvalue(gz, rl, result, node);
1324	1343	}
	1344	const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
	1345	const result = try gz.addUnNode(.struct_init_empty, ty_inst, node);
	1346	return rvalue(gz, rl, result, node);
	1347	} else {
	1348	return astgen.failNode(
	1349	struct_init.ast.type_expr,
	1350	"initializing array with struct syntax",
	1351	.{},
	1352	);
1325	1353	}
1326		const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
1327		const result = try gz.addUnNode(.struct_init_empty, ty_inst, node);
1328		return rvalue(gz, rl, result, node);
1329	1354	}
	1355
1330	1356	switch (rl) {
1331	1357	.discard => {
1332	1358	if (struct_init.ast.type_expr != 0)
...	...	@@ -1570,7 +1596,7 @@ fn breakExpr(parent_gz: GenZir, parent_scope: Scope, node: ast.Node.Index) Inn
1570	1596	const defer_scope = scope.cast(Scope.Defer).?;
1571	1597	scope = defer_scope.parent;
1572	1598	const expr_node = node_datas[defer_scope.defer_node].rhs;
1573		try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
	1599	_ = try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
1574	1600	},
1575	1601	.defer_error => scope = scope.cast(Scope.Defer).?.parent,
1576	1602	.top => unreachable,
...	...	@@ -1623,7 +1649,7 @@ fn continueExpr(parent_gz: GenZir, parent_scope: Scope, node: ast.Node.Index)
1623	1649	const defer_scope = scope.cast(Scope.Defer).?;
1624	1650	scope = defer_scope.parent;
1625	1651	const expr_node = node_datas[defer_scope.defer_node].rhs;
1626		try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
	1652	_ = try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
1627	1653	},
1628	1654	.defer_error => scope = scope.cast(Scope.Defer).?.parent,
1629	1655	.namespace => break,
...	...	@@ -1679,7 +1705,7 @@ fn checkLabelRedefinition(astgen: AstGen, parent_scope: Scope, label: ast.Toke
1679	1705	}, &[_]u32{
1680	1706	try astgen.errNoteTok(
1681	1707	prev_label.token,
1682		"previous definition is here",
	1708	"previous definition here",
1683	1709	.{},
1684	1710	),
1685	1711	});
...	...	@@ -1785,8 +1811,23 @@ fn blockExprStmts(gz: GenZir, parent_scope: Scope, statements: []const ast.Nod
1785	1811	var block_arena = std.heap.ArenaAllocator.init(gz.astgen.gpa);
1786	1812	defer block_arena.deinit();
1787	1813
	1814	var noreturn_src_node: ast.Node.Index = 0;
1788	1815	var scope = parent_scope;
1789	1816	for (statements) \|statement\| {
	1817	if (noreturn_src_node != 0) {
	1818	return astgen.failNodeNotes(
	1819	statement,
	1820	"unreachable code",
	1821	.{},
	1822	&[_]u32{
	1823	try astgen.errNoteNode(
	1824	noreturn_src_node,
	1825	"control flow is diverted here",
	1826	.{},
	1827	),
	1828	},
	1829	);
	1830	}
1790	1831	switch (node_tags[statement]) {
1791	1832	// zig fmt: off
1792	1833	.global_var_decl => scope = try varDecl(gz, scope, statement, &block_arena.allocator, tree.globalVarDecl(statement)),
...	...	@@ -1814,7 +1855,7 @@ fn blockExprStmts(gz: GenZir, parent_scope: Scope, statements: []const ast.Nod
1814	1855	.assign_mul => try assignOp(gz, scope, statement, .mul),
1815	1856	.assign_mul_wrap => try assignOp(gz, scope, statement, .mulwrap),
1816	1857
1817		else => try unusedResultExpr(gz, scope, statement),
	1858	else => noreturn_src_node = try unusedResultExpr(gz, scope, statement),
1818	1859	// zig fmt: on
1819	1860	}
1820	1861	}
...	...	@@ -1823,11 +1864,14 @@ fn blockExprStmts(gz: GenZir, parent_scope: Scope, statements: []const ast.Nod
1823	1864	try checkUsed(gz, parent_scope, scope);
1824	1865	}
1825	1866
1826		fn unusedResultExpr(gz: GenZir, scope: Scope, statement: ast.Node.Index) InnerError!void {
	1867	/// Returns AST source node of the thing that is noreturn if the statement is definitely `noreturn`.
	1868	/// Otherwise returns 0.
	1869	fn unusedResultExpr(gz: GenZir, scope: Scope, statement: ast.Node.Index) InnerError!ast.Node.Index {
1827	1870	try emitDbgNode(gz, statement);
1828	1871	// We need to emit an error if the result is not `noreturn` or `void`, but
1829	1872	// we want to avoid adding the ZIR instruction if possible for performance.
1830	1873	const maybe_unused_result = try expr(gz, scope, .none, statement);
	1874	var noreturn_src_node: ast.Node.Index = 0;
1831	1875	const elide_check = if (gz.refToIndex(maybe_unused_result)) \|inst\| b: {
1832	1876	// Note that this array becomes invalid after appending more items to it
1833	1877	// in the above while loop.
...	...	@@ -2061,15 +2105,7 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: ast.Node.Index) Inner
2061	2105	.extended,
2062	2106	=> break :b false,
2063	2107
2064		// ZIR instructions that are always either `noreturn` or `void`.
2065		.breakpoint,
2066		.fence,
2067		.dbg_stmt,
2068		.ensure_result_used,
2069		.ensure_result_non_error,
2070		.@"export",
2071		.set_eval_branch_quota,
2072		.ensure_err_payload_void,
	2108	// ZIR instructions that are always `noreturn`.
2073	2109	.@"break",
2074	2110	.break_inline,
2075	2111	.condbr,
...	...	@@ -2078,16 +2114,30 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: ast.Node.Index) Inner
2078	2114	.ret_node,
2079	2115	.ret_coerce,
2080	2116	.@"unreachable",
	2117	.repeat,
	2118	.repeat_inline,
	2119	.panic,
	2120	=> {
	2121	noreturn_src_node = statement;
	2122	break :b true;
	2123	},
	2124
	2125	// ZIR instructions that are always `void`.
	2126	.breakpoint,
	2127	.fence,
	2128	.dbg_stmt,
	2129	.ensure_result_used,
	2130	.ensure_result_non_error,
	2131	.@"export",
	2132	.set_eval_branch_quota,
	2133	.ensure_err_payload_void,
2081	2134	.store,
2082	2135	.store_node,
2083	2136	.store_to_block_ptr,
2084	2137	.store_to_inferred_ptr,
2085	2138	.resolve_inferred_alloc,
2086		.repeat,
2087		.repeat_inline,
2088	2139	.validate_struct_init_ptr,
2089	2140	.validate_array_init_ptr,
2090		.panic,
2091	2141	.set_align_stack,
2092	2142	.set_cold,
2093	2143	.set_float_mode,
...	...	@@ -2097,15 +2147,19 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: ast.Node.Index) Inner
2097	2147	} else switch (maybe_unused_result) {
2098	2148	.none => unreachable,
2099	2149
2100		.void_value,
2101		.unreachable_value,
2102		=> true,
	2150	.unreachable_value => b: {
	2151	noreturn_src_node = statement;
	2152	break :b true;
	2153	},
	2154
	2155	.void_value => true,
2103	2156
2104	2157	else => false,
2105	2158	};
2106	2159	if (!elide_check) {
2107	2160	_ = try gz.addUnNode(.ensure_result_used, maybe_unused_result, statement);
2108	2161	}
	2162	return noreturn_src_node;
2109	2163	}
2110	2164
2111	2165	fn genDefers(
...	...	@@ -2132,7 +2186,7 @@ fn genDefers(
2132	2186	const prev_in_defer = gz.in_defer;
2133	2187	gz.in_defer = true;
2134	2188	defer gz.in_defer = prev_in_defer;
2135		try unusedResultExpr(gz, defer_scope.parent, expr_node);
	2189	_ = try unusedResultExpr(gz, defer_scope.parent, expr_node);
2136	2190	},
2137	2191	.defer_error => {
2138	2192	const defer_scope = scope.cast(Scope.Defer).?;
...	...	@@ -2142,7 +2196,7 @@ fn genDefers(
2142	2196	const prev_in_defer = gz.in_defer;
2143	2197	gz.in_defer = true;
2144	2198	defer gz.in_defer = prev_in_defer;
2145		try unusedResultExpr(gz, defer_scope.parent, expr_node);
	2199	_ = try unusedResultExpr(gz, defer_scope.parent, expr_node);
2146	2200	},
2147	2201	.namespace => unreachable,
2148	2202	.top => unreachable,
...	...	@@ -2163,25 +2217,15 @@ fn checkUsed(
2163	2217	.gen_zir => scope = scope.cast(GenZir).?.parent,
2164	2218	.local_val => {
2165	2219	const s = scope.cast(Scope.LocalVal).?;
2166		switch (s.used) {
2167		.used => {},
2168		.fn_param => return astgen.failTok(s.token_src, "unused function parameter", .{}),
2169		.constant => return astgen.failTok(s.token_src, "unused local constant", .{}),
2170		.variable => unreachable,
2171		.loop_index => unreachable,
2172		.capture => return astgen.failTok(s.token_src, "unused capture", .{}),
	2220	if (!s.used) {
	2221	return astgen.failTok(s.token_src, "unused {s}", .{@tagName(s.id_cat)});
2173	2222	}
2174	2223	scope = s.parent;
2175	2224	},
2176	2225	.local_ptr => {
2177	2226	const s = scope.cast(Scope.LocalPtr).?;
2178		switch (s.used) {
2179		.used => {},
2180		.fn_param => unreachable,
2181		.constant => return astgen.failTok(s.token_src, "unused local constant", .{}),
2182		.variable => return astgen.failTok(s.token_src, "unused local variable", .{}),
2183		.loop_index => return astgen.failTok(s.token_src, "unused loop index capture", .{}),
2184		.capture => unreachable,
	2227	if (!s.used) {
	2228	return astgen.failTok(s.token_src, "unused {s}", .{@tagName(s.id_cat)});
2185	2229	}
2186	2230	scope = s.parent;
2187	2231	},
...	...	@@ -2221,65 +2265,13 @@ fn varDecl(
2221	2265	const token_tags = tree.tokens.items(.tag);
2222	2266
2223	2267	const name_token = var_decl.ast.mut_token + 1;
	2268	const ident_name_raw = tree.tokenSlice(name_token);
	2269	if (mem.eql(u8, ident_name_raw, "_")) {
	2270	return astgen.failTok(name_token, "'_' used as an identifier without @\"_\" syntax", .{});
	2271	}
2224	2272	const ident_name = try astgen.identAsString(name_token);
2225	2273
2226		// Local variables shadowing detection, including function parameters.
2227		{
2228		var s = scope;
2229		while (true) switch (s.tag) {
2230		.local_val => {
2231		const local_val = s.cast(Scope.LocalVal).?;
2232		if (local_val.name == ident_name) {
2233		const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
2234		defer gpa.free(name);
2235		return astgen.failTokNotes(name_token, "redeclaration of '{s}'", .{
2236		name,
2237		}, &[_]u32{
2238		try astgen.errNoteTok(
2239		local_val.token_src,
2240		"previously declared here",
2241		.{},
2242		),
2243		});
2244		}
2245		s = local_val.parent;
2246		},
2247		.local_ptr => {
2248		const local_ptr = s.cast(Scope.LocalPtr).?;
2249		if (local_ptr.name == ident_name) {
2250		const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
2251		defer gpa.free(name);
2252		return astgen.failTokNotes(name_token, "redeclaration of '{s}'", .{
2253		name,
2254		}, &[_]u32{
2255		try astgen.errNoteTok(
2256		local_ptr.token_src,
2257		"previously declared here",
2258		.{},
2259		),
2260		});
2261		}
2262		s = local_ptr.parent;
2263		},
2264		.namespace => {
2265		const ns = s.cast(Scope.Namespace).?;
2266		const decl_node = ns.decls.get(ident_name) orelse {
2267		s = ns.parent;
2268		continue;
2269		};
2270		const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
2271		defer gpa.free(name);
2272		return astgen.failTokNotes(name_token, "local shadows declaration of '{s}'", .{
2273		name,
2274		}, &[_]u32{
2275		try astgen.errNoteNode(decl_node, "declared here", .{}),
2276		});
2277		},
2278		.gen_zir => s = s.cast(GenZir).?.parent,
2279		.defer_normal, .defer_error => s = s.cast(Scope.Defer).?.parent,
2280		.top => break,
2281		};
2282		}
	2274	try astgen.detectLocalShadowing(scope, ident_name, name_token);
2283	2275
2284	2276	if (var_decl.ast.init_node == 0) {
2285	2277	return astgen.failNode(node, "variables must be initialized", .{});
...	...	@@ -2303,7 +2295,8 @@ fn varDecl(
2303	2295	const result_loc: ResultLoc = if (var_decl.ast.type_node != 0) .{
2304	2296	.ty = try typeExpr(gz, scope, var_decl.ast.type_node),
2305	2297	} else .none;
2306		const init_inst = try expr(gz, scope, result_loc, var_decl.ast.init_node);
	2298	const init_inst = try reachableExpr(gz, scope, result_loc, var_decl.ast.init_node, node);
	2299
2307	2300	const sub_scope = try block_arena.create(Scope.LocalVal);
2308	2301	sub_scope.* = .{
2309	2302	.parent = scope,
...	...	@@ -2311,7 +2304,7 @@ fn varDecl(
2311	2304	.name = ident_name,
2312	2305	.inst = init_inst,
2313	2306	.token_src = name_token,
2314		.used = .constant,
	2307	.id_cat = .@"local constant",
2315	2308	};
2316	2309	return &sub_scope.base;
2317	2310	}
...	...	@@ -2353,7 +2346,8 @@ fn varDecl(
2353	2346	init_scope.rl_ptr = alloc;
2354	2347	}
2355	2348	const init_result_loc: ResultLoc = .{ .block_ptr = &init_scope };
2356		const init_inst = try expr(&init_scope, &init_scope.base, init_result_loc, var_decl.ast.init_node);
	2349	const init_inst = try reachableExpr(&init_scope, &init_scope.base, init_result_loc, var_decl.ast.init_node, node);
	2350
2357	2351	const zir_tags = astgen.instructions.items(.tag);
2358	2352	const zir_datas = astgen.instructions.items(.data);
2359	2353
...	...	@@ -2379,7 +2373,7 @@ fn varDecl(
2379	2373	.name = ident_name,
2380	2374	.inst = init_inst,
2381	2375	.token_src = name_token,
2382		.used = .constant,
	2376	.id_cat = .@"local constant",
2383	2377	};
2384	2378	return &sub_scope.base;
2385	2379	}
...	...	@@ -2409,7 +2403,7 @@ fn varDecl(
2409	2403	.ptr = init_scope.rl_ptr,
2410	2404	.token_src = name_token,
2411	2405	.maybe_comptime = true,
2412		.used = .constant,
	2406	.id_cat = .@"local constant",
2413	2407	};
2414	2408	return &sub_scope.base;
2415	2409	},
...	...	@@ -2454,7 +2448,7 @@ fn varDecl(
2454	2448	resolve_inferred_alloc = alloc;
2455	2449	break :a .{ .alloc = alloc, .result_loc = .{ .inferred_ptr = alloc } };
2456	2450	};
2457		_ = try expr(gz, scope, var_data.result_loc, var_decl.ast.init_node);
	2451	_ = try reachableExpr(gz, scope, var_data.result_loc, var_decl.ast.init_node, node);
2458	2452	if (resolve_inferred_alloc != .none) {
2459	2453	_ = try gz.addUnNode(.resolve_inferred_alloc, resolve_inferred_alloc, node);
2460	2454	}
...	...	@@ -2466,7 +2460,7 @@ fn varDecl(
2466	2460	.ptr = var_data.alloc,
2467	2461	.token_src = name_token,
2468	2462	.maybe_comptime = is_comptime,
2469		.used = .variable,
	2463	.id_cat = .@"local variable",
2470	2464	};
2471	2465	return &sub_scope.base;
2472	2466	},
...	...	@@ -2956,7 +2950,11 @@ fn fnDecl(
2956	2950	var it = fn_proto.iterate(tree.*);
2957	2951	while (it.next()) \|param\| : (i += 1) {
2958	2952	const name_token = param.name_token orelse {
2959		return astgen.failNode(param.type_expr, "missing parameter name", .{});
	2953	if (param.anytype_ellipsis3) \|tok\| {
	2954	return astgen.failTok(tok, "missing parameter name", .{});
	2955	} else {
	2956	return astgen.failNode(param.type_expr, "missing parameter name", .{});
	2957	}
2960	2958	};
2961	2959	if (param.type_expr != 0)
2962	2960	_ = try typeExpr(&fn_gz, params_scope, param.type_expr);
...	...	@@ -2965,7 +2963,7 @@ fn fnDecl(
2965	2963	const param_name = try astgen.identAsString(name_token);
2966	2964	// Create an arg instruction. This is needed to emit a semantic analysis
2967	2965	// error for shadowing decls.
2968		// TODO emit a compile error here for shadowing locals.
	2966	try astgen.detectLocalShadowing(params_scope, param_name, name_token);
2969	2967	const arg_inst = try fn_gz.addStrTok(.arg, param_name, name_token);
2970	2968	const sub_scope = try astgen.arena.create(Scope.LocalVal);
2971	2969	sub_scope.* = .{
...	...	@@ -2974,7 +2972,7 @@ fn fnDecl(
2974	2972	.name = param_name,
2975	2973	.inst = arg_inst,
2976	2974	.token_src = name_token,
2977		.used = .fn_param,
	2975	.id_cat = .@"function parameter",
2978	2976	};
2979	2977	params_scope = &sub_scope.base;
2980	2978
...	...	@@ -4005,7 +4003,18 @@ fn containerDecl(
4005	4003	return astgen.failTok(comptime_token, "enum fields cannot be marked comptime", .{});
4006	4004	}
4007	4005	if (member.ast.type_expr != 0) {
4008		return astgen.failNode(member.ast.type_expr, "enum fields do not have types", .{});
	4006	return astgen.failNodeNotes(
	4007	member.ast.type_expr,
	4008	"enum fields do not have types",
	4009	.{},
	4010	&[_]u32{
	4011	try astgen.errNoteNode(
	4012	node,
	4013	"consider 'union(enum)' here to make it a tagged union",
	4014	.{},
	4015	),
	4016	},
	4017	);
4009	4018	}
4010	4019	// Alignment expressions in enums are caught by the parser.
4011	4020	assert(member.ast.align_expr == 0);
...	...	@@ -4523,7 +4532,7 @@ fn tryExpr(
4523	4532	return astgen.failNode(node, "invalid 'try' outside function scope", .{});
4524	4533	};
4525	4534
4526		if (parent_gz.in_defer) return astgen.failNode(node, "try is not allowed inside defer expression", .{});
	4535	if (parent_gz.in_defer) return astgen.failNode(node, "'try' not allowed inside defer expression", .{});
4527	4536
4528	4537	var block_scope = parent_gz.makeSubBlock(scope);
4529	4538	block_scope.setBreakResultLoc(rl);
...	...	@@ -4638,7 +4647,7 @@ fn orelseCatchExpr(
4638	4647	.name = err_name,
4639	4648	.inst = try then_scope.addUnNode(unwrap_code_op, operand, node),
4640	4649	.token_src = payload,
4641		.used = .capture,
	4650	.id_cat = .@"capture",
4642	4651	};
4643	4652	break :blk &err_val_scope.base;
4644	4653	};
...	...	@@ -4930,7 +4939,7 @@ fn ifExpr(
4930	4939	.name = ident_name,
4931	4940	.inst = payload_inst,
4932	4941	.token_src = payload_token,
4933		.used = .capture,
	4942	.id_cat = .@"capture",
4934	4943	};
4935	4944	break :s &payload_val_scope.base;
4936	4945	} else {
...	...	@@ -4952,7 +4961,7 @@ fn ifExpr(
4952	4961	.name = ident_name,
4953	4962	.inst = payload_inst,
4954	4963	.token_src = ident_token,
4955		.used = .capture,
	4964	.id_cat = .@"capture",
4956	4965	};
4957	4966	break :s &payload_val_scope.base;
4958	4967	} else {
...	...	@@ -4993,7 +5002,7 @@ fn ifExpr(
4993	5002	.name = ident_name,
4994	5003	.inst = payload_inst,
4995	5004	.token_src = error_token,
4996		.used = .capture,
	5005	.id_cat = .@"capture",
4997	5006	};
4998	5007	break :s &payload_val_scope.base;
4999	5008	} else {
...	...	@@ -5187,7 +5196,7 @@ fn whileExpr(
5187	5196	.name = ident_name,
5188	5197	.inst = payload_inst,
5189	5198	.token_src = payload_token,
5190		.used = .capture,
	5199	.id_cat = .@"capture",
5191	5200	};
5192	5201	break :s &payload_val_scope.base;
5193	5202	} else {
...	...	@@ -5209,7 +5218,7 @@ fn whileExpr(
5209	5218	.name = ident_name,
5210	5219	.inst = payload_inst,
5211	5220	.token_src = ident_token,
5212		.used = .capture,
	5221	.id_cat = .@"capture",
5213	5222	};
5214	5223	break :s &payload_val_scope.base;
5215	5224	} else {
...	...	@@ -5266,7 +5275,7 @@ fn whileExpr(
5266	5275	.name = ident_name,
5267	5276	.inst = payload_inst,
5268	5277	.token_src = error_token,
5269		.used = .capture,
	5278	.id_cat = .@"capture",
5270	5279	};
5271	5280	break :s &payload_val_scope.base;
5272	5281	} else {
...	...	@@ -5405,7 +5414,7 @@ fn forExpr(
5405	5414	.name = name_str_index,
5406	5415	.inst = payload_inst,
5407	5416	.token_src = ident,
5408		.used = .capture,
	5417	.id_cat = .@"capture",
5409	5418	};
5410	5419	payload_sub_scope = &payload_val_scope.base;
5411	5420	} else if (is_ptr) {
...	...	@@ -5429,7 +5438,7 @@ fn forExpr(
5429	5438	.ptr = index_ptr,
5430	5439	.token_src = index_token,
5431	5440	.maybe_comptime = is_inline,
5432		.used = .loop_index,
	5441	.id_cat = .@"loop index capture",
5433	5442	};
5434	5443	break :blk &index_scope.base;
5435	5444	};
...	...	@@ -5529,7 +5538,7 @@ fn switchExpr(
5529	5538	&[_]u32{
5530	5539	try astgen.errNoteTok(
5531	5540	src,
5532		"previous else prong is here",
	5541	"previous else prong here",
5533	5542	.{},
5534	5543	),
5535	5544	},
...	...	@@ -5542,12 +5551,12 @@ fn switchExpr(
5542	5551	&[_]u32{
5543	5552	try astgen.errNoteTok(
5544	5553	case_src,
5545		"else prong is here",
	5554	"else prong here",
5546	5555	.{},
5547	5556	),
5548	5557	try astgen.errNoteTok(
5549	5558	some_underscore,
5550		"'_' prong is here",
	5559	"'_' prong here",
5551	5560	.{},
5552	5561	),
5553	5562	},
...	...	@@ -5570,7 +5579,7 @@ fn switchExpr(
5570	5579	&[_]u32{
5571	5580	try astgen.errNoteTok(
5572	5581	src,
5573		"previous '_' prong is here",
	5582	"previous '_' prong here",
5574	5583	.{},
5575	5584	),
5576	5585	},
...	...	@@ -5583,12 +5592,12 @@ fn switchExpr(
5583	5592	&[_]u32{
5584	5593	try astgen.errNoteTok(
5585	5594	some_else,
5586		"else prong is here",
	5595	"else prong here",
5587	5596	.{},
5588	5597	),
5589	5598	try astgen.errNoteTok(
5590	5599	case_src,
5591		"'_' prong is here",
	5600	"'_' prong here",
5592	5601	.{},
5593	5602	),
5594	5603	},
...	...	@@ -5674,7 +5683,7 @@ fn switchExpr(
5674	5683	.name = capture_name,
5675	5684	.inst = capture,
5676	5685	.token_src = payload_token,
5677		.used = .capture,
	5686	.id_cat = .@"capture",
5678	5687	};
5679	5688	break :blk &capture_val_scope.base;
5680	5689	};
...	...	@@ -5768,7 +5777,7 @@ fn switchExpr(
5768	5777	.name = capture_name,
5769	5778	.inst = capture,
5770	5779	.token_src = payload_token,
5771		.used = .capture,
	5780	.id_cat = .@"capture",
5772	5781	};
5773	5782	break :blk &capture_val_scope.base;
5774	5783	};
...	...	@@ -6150,10 +6159,11 @@ fn identifier(
6150	6159	const main_tokens = tree.nodes.items(.main_token);
6151	6160
6152	6161	const ident_token = main_tokens[ident];
6153		const ident_name = try astgen.identifierTokenString(ident_token);
6154		if (mem.eql(u8, ident_name, "_")) {
6155		return astgen.failNode(ident, "'_' may not be used as an identifier", .{});
	6162	const ident_name_raw = tree.tokenSlice(ident_token);
	6163	if (mem.eql(u8, ident_name_raw, "_")) {
	6164	return astgen.failNode(ident, "'_' used as an identifier without @\"_\" syntax", .{});
6156	6165	}
	6166	const ident_name = try astgen.identifierTokenString(ident_token);
6157	6167
6158	6168	if (simple_types.get(ident_name)) \|zir_const_ref\| {
6159	6169	return rvalue(gz, rl, zir_const_ref, ident);
...	...	@@ -6197,7 +6207,7 @@ fn identifier(
6197	6207	const local_val = s.cast(Scope.LocalVal).?;
6198	6208
6199	6209	if (local_val.name == name_str_index) {
6200		local_val.used = .used;
	6210	local_val.used = true;
6201	6211	// Captures of non-locals need to be emitted as decl_val or decl_ref.
6202	6212	// This might be capturable depending on if it is comptime known.
6203	6213	if (!hit_namespace) {
...	...	@@ -6209,7 +6219,7 @@ fn identifier(
6209	6219	.local_ptr => {
6210	6220	const local_ptr = s.cast(Scope.LocalPtr).?;
6211	6221	if (local_ptr.name == name_str_index) {
6212		local_ptr.used = .used;
	6222	local_ptr.used = true;
6213	6223	if (hit_namespace) {
6214	6224	if (local_ptr.maybe_comptime)
6215	6225	break
...	...	@@ -6333,20 +6343,76 @@ fn charLiteral(gz: *GenZir, rl: ResultLoc, node: ast.Node.Index) !Zir.Inst.Ref {
6333	6343	const main_token = main_tokens[node];
6334	6344	const slice = tree.tokenSlice(main_token);
6335	6345
6336		var bad_index: usize = undefined;
6337		const value = std.zig.parseCharLiteral(slice, &bad_index) catch \|err\| switch (err) {
6338		error.InvalidCharacter => {
6339		const bad_byte = slice[bad_index];
	6346	switch (std.zig.parseCharLiteral(slice)) {
	6347	.success => \|codepoint\| {
	6348	const result = try gz.addInt(codepoint);
	6349	return rvalue(gz, rl, result, node);
	6350	},
	6351	.invalid_escape_character => \|bad_index\| {
6340	6352	return astgen.failOff(
6341	6353	main_token,
6342	6354	@intCast(u32, bad_index),
6343		"invalid character: '{c}'\n",
6344		.{bad_byte},
	6355	"invalid escape character: '{c}'",
	6356	.{slice[bad_index]},
6345	6357	);
6346	6358	},
6347		};
6348		const result = try gz.addInt(value);
6349		return rvalue(gz, rl, result, node);
	6359	.expected_hex_digit => \|bad_index\| {
	6360	return astgen.failOff(
	6361	main_token,
	6362	@intCast(u32, bad_index),
	6363	"expected hex digit, found '{c}'",
	6364	.{slice[bad_index]},
	6365	);
	6366	},
	6367	.empty_unicode_escape_sequence => \|bad_index\| {
	6368	return astgen.failOff(
	6369	main_token,
	6370	@intCast(u32, bad_index),
	6371	"empty unicode escape sequence",
	6372	.{},
	6373	);
	6374	},
	6375	.expected_hex_digit_or_rbrace => \|bad_index\| {
	6376	return astgen.failOff(
	6377	main_token,
	6378	@intCast(u32, bad_index),
	6379	"expected hex digit or '}}', found '{c}'",
	6380	.{slice[bad_index]},
	6381	);
	6382	},
	6383	.unicode_escape_overflow => \|bad_index\| {
	6384	return astgen.failOff(
	6385	main_token,
	6386	@intCast(u32, bad_index),
	6387	"unicode escape too large to be a valid codepoint",
	6388	.{},
	6389	);
	6390	},
	6391	.expected_lbrace => \|bad_index\| {
	6392	return astgen.failOff(
	6393	main_token,
	6394	@intCast(u32, bad_index),
	6395	"expected '{{', found '{c}",
	6396	.{slice[bad_index]},
	6397	);
	6398	},
	6399	.expected_end => \|bad_index\| {
	6400	return astgen.failOff(
	6401	main_token,
	6402	@intCast(u32, bad_index),
	6403	"expected ending single quote ('), found '{c}",
	6404	.{slice[bad_index]},
	6405	);
	6406	},
	6407	.invalid_character => \|bad_index\| {
	6408	return astgen.failOff(
	6409	main_token,
	6410	@intCast(u32, bad_index),
	6411	"invalid byte in character literal: '{c}'",
	6412	.{slice[bad_index]},
	6413	);
	6414	},
	6415	}
6350	6416	}
6351	6417
6352	6418	fn integerLiteral(gz: *GenZir, rl: ResultLoc, node: ast.Node.Index) InnerError!Zir.Inst.Ref {
...	...	@@ -6489,7 +6555,7 @@ fn asmExpr(
6489	6555	.local_val => {
6490	6556	const local_val = s.cast(Scope.LocalVal).?;
6491	6557	if (local_val.name == str_index) {
6492		local_val.used = .used;
	6558	local_val.used = true;
6493	6559	break;
6494	6560	}
6495	6561	s = local_val.parent;
...	...	@@ -6497,7 +6563,7 @@ fn asmExpr(
6497	6563	.local_ptr => {
6498	6564	const local_ptr = s.cast(Scope.LocalPtr).?;
6499	6565	if (local_ptr.name == str_index) {
6500		local_ptr.used = .used;
	6566	local_ptr.used = true;
6501	6567	break;
6502	6568	}
6503	6569	s = local_ptr.parent;
...	...	@@ -6585,14 +6651,14 @@ fn as(
6585	6651	const dest_type = try typeExpr(gz, scope, lhs);
6586	6652	switch (rl) {
6587	6653	.none, .none_or_ref, .discard, .ref, .ty => {
6588		const result = try expr(gz, scope, .{ .ty = dest_type }, rhs);
	6654	const result = try reachableExpr(gz, scope, .{ .ty = dest_type }, rhs, node);
6589	6655	return rvalue(gz, rl, result, node);
6590	6656	},
6591	6657	.ptr, .inferred_ptr => \|result_ptr\| {
6592		return asRlPtr(gz, scope, rl, result_ptr, rhs, dest_type);
	6658	return asRlPtr(gz, scope, rl, node, result_ptr, rhs, dest_type);
6593	6659	},
6594	6660	.block_ptr => \|block_scope\| {
6595		return asRlPtr(gz, scope, rl, block_scope.rl_ptr, rhs, dest_type);
	6661	return asRlPtr(gz, scope, rl, node, block_scope.rl_ptr, rhs, dest_type);
6596	6662	},
6597	6663	}
6598	6664	}
...	...	@@ -6646,6 +6712,7 @@ fn asRlPtr(
6646	6712	parent_gz: *GenZir,
6647	6713	scope: *Scope,
6648	6714	rl: ResultLoc,
	6715	src_node: ast.Node.Index,
6649	6716	result_ptr: Zir.Inst.Ref,
6650	6717	operand_node: ast.Node.Index,
6651	6718	dest_type: Zir.Inst.Ref,
...	...	@@ -6659,7 +6726,7 @@ fn asRlPtr(
6659	6726	defer as_scope.instructions.deinit(astgen.gpa);
6660	6727
6661	6728	as_scope.rl_ptr = try as_scope.addBin(.coerce_result_ptr, dest_type, result_ptr);
6662		const result = try expr(&as_scope, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node);
	6729	const result = try reachableExpr(&as_scope, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node, src_node);
6663	6730	const parent_zir = &parent_gz.instructions;
6664	6731	if (as_scope.rvalue_rl_count == 1) {
6665	6732	// Busted! This expression didn't actually need a pointer.
...	...	@@ -6738,13 +6805,14 @@ fn typeOf(
6738	6805	return gz.astgen.failNode(node, "expected at least 1 argument, found 0", .{});
6739	6806	}
6740	6807	if (params.len == 1) {
6741		const result = try gz.addUnNode(.typeof, try expr(gz, scope, .none, params[0]), node);
	6808	const expr_result = try reachableExpr(gz, scope, .none, params[0], node);
	6809	const result = try gz.addUnNode(.typeof, expr_result, node);
6742	6810	return rvalue(gz, rl, result, node);
6743	6811	}
6744	6812	const arena = gz.astgen.arena;
6745	6813	var items = try arena.alloc(Zir.Inst.Ref, params.len);
6746	6814	for (params) \|param, param_i\| {
6747		items[param_i] = try expr(gz, scope, .none, param);
	6815	items[param_i] = try reachableExpr(gz, scope, .none, param, node);
6748	6816	}
6749	6817
6750	6818	const result = try gz.addExtendedMultiOp(.typeof_peer, node, items);
...	...	@@ -6778,7 +6846,7 @@ fn builtinCall(
6778	6846	if (info.param_count) \|expected\| {
6779	6847	if (expected != params.len) {
6780	6848	const s = if (expected == 1) "" else "s";
6781		return astgen.failNode(node, "expected {d} parameter{s}, found {d}", .{
	6849	return astgen.failNode(node, "expected {d} argument{s}, found {d}", .{
6782	6850	expected, s, params.len,
6783	6851	});
6784	6852	}
...	...	@@ -6796,8 +6864,13 @@ fn builtinCall(
6796	6864	}
6797	6865	const str_lit_token = main_tokens[operand_node];
6798	6866	const str = try astgen.strLitAsString(str_lit_token);
6799		try astgen.imports.put(astgen.gpa, str.index, {});
6800	6867	const result = try gz.addStrTok(.import, str.index, str_lit_token);
	6868	if (gz.refToIndex(result)) \|import_inst_index\| {
	6869	const gop = try astgen.imports.getOrPut(astgen.gpa, str.index);
	6870	if (!gop.found_existing) {
	6871	gop.value_ptr.* = import_inst_index;
	6872	}
	6873	}
6801	6874	return rvalue(gz, rl, result, node);
6802	6875	},
6803	6876	.compile_log => {
...	...	@@ -6846,7 +6919,7 @@ fn builtinCall(
6846	6919	.local_val => {
6847	6920	const local_val = s.cast(Scope.LocalVal).?;
6848	6921	if (local_val.name == decl_name) {
6849		local_val.used = .used;
	6922	local_val.used = true;
6850	6923	break;
6851	6924	}
6852	6925	s = local_val.parent;
...	...	@@ -6856,7 +6929,7 @@ fn builtinCall(
6856	6929	if (local_ptr.name == decl_name) {
6857	6930	if (!local_ptr.maybe_comptime)
6858	6931	return astgen.failNode(params[0], "unable to export runtime-known value", .{});
6859		local_ptr.used = .used;
	6932	local_ptr.used = true;
6860	6933	break;
6861	6934	}
6862	6935	s = local_ptr.parent;
...	...	@@ -8423,15 +8496,15 @@ const Scope = struct {
8423	8496	top,
8424	8497	};
8425	8498
8426		// either .used or the type of the var/constant
8427		const Used = enum {
8428		fn_param,
8429		constant,
8430		variable,
8431		loop_index,
8432		capture,
8433		used,
	8499	/// The category of identifier. These tag names are user-visible in compile errors.
	8500	const IdCat = enum {
	8501	@"function parameter",
	8502	@"local constant",
	8503	@"local variable",
	8504	@"loop index capture",
	8505	@"capture",
8434	8506	};
	8507
8435	8508	/// This is always a `const` local and importantly the `inst` is a value type, not a pointer.
8436	8509	/// This structure lives as long as the AST generation of the Block
8437	8510	/// node that contains the variable.
...	...	@@ -8446,8 +8519,9 @@ const Scope = struct {
8446	8519	token_src: ast.TokenIndex,
8447	8520	/// String table index.
8448	8521	name: u32,
8449		/// has this variable been referenced?
8450		used: Used,
	8522	id_cat: IdCat,
	8523	/// Track whether the name has been referenced.
	8524	used: bool = false,
8451	8525	};
8452	8526
8453	8527	/// This could be a `const` or `var` local. It has a pointer instead of a value.
...	...	@@ -8464,10 +8538,12 @@ const Scope = struct {
8464	8538	token_src: ast.TokenIndex,
8465	8539	/// String table index.
8466	8540	name: u32,
8467		/// true means we find out during Sema whether the value is comptime. false means it is already known at AstGen the value is runtime-known.
	8541	id_cat: IdCat,
	8542	/// true means we find out during Sema whether the value is comptime.
	8543	/// false means it is already known at AstGen the value is runtime-known.
8468	8544	maybe_comptime: bool,
8469		/// has this variable been referenced?
8470		used: Used,
	8545	/// Track whether the name has been referenced.
	8546	used: bool = false,
8471	8547	};
8472	8548
8473	8549	const Defer = struct {
...	...	@@ -9558,6 +9634,71 @@ fn declareNewName(
9558	9634	}
9559	9635	}
9560	9636
	9637	/// Local variables shadowing detection, including function parameters.
	9638	fn detectLocalShadowing(
	9639	astgen: *AstGen,
	9640	scope: *Scope,
	9641	ident_name: u32,
	9642	name_token: ast.TokenIndex,
	9643	) !void {
	9644	const gpa = astgen.gpa;
	9645
	9646	var s = scope;
	9647	while (true) switch (s.tag) {
	9648	.local_val => {
	9649	const local_val = s.cast(Scope.LocalVal).?;
	9650	if (local_val.name == ident_name) {
	9651	const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
	9652	defer gpa.free(name);
	9653	return astgen.failTokNotes(name_token, "redeclaration of {s} '{s}'", .{
	9654	@tagName(local_val.id_cat), name,
	9655	}, &[_]u32{
	9656	try astgen.errNoteTok(
	9657	local_val.token_src,
	9658	"previous declaration here",
	9659	.{},
	9660	),
	9661	});
	9662	}
	9663	s = local_val.parent;
	9664	},
	9665	.local_ptr => {
	9666	const local_ptr = s.cast(Scope.LocalPtr).?;
	9667	if (local_ptr.name == ident_name) {
	9668	const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
	9669	defer gpa.free(name);
	9670	return astgen.failTokNotes(name_token, "redeclaration of {s} '{s}'", .{
	9671	@tagName(local_ptr.id_cat), name,
	9672	}, &[_]u32{
	9673	try astgen.errNoteTok(
	9674	local_ptr.token_src,
	9675	"previous declaration here",
	9676	.{},
	9677	),
	9678	});
	9679	}
	9680	s = local_ptr.parent;
	9681	},
	9682	.namespace => {
	9683	const ns = s.cast(Scope.Namespace).?;
	9684	const decl_node = ns.decls.get(ident_name) orelse {
	9685	s = ns.parent;
	9686	continue;
	9687	};
	9688	const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
	9689	defer gpa.free(name);
	9690	return astgen.failTokNotes(name_token, "local shadows declaration of '{s}'", .{
	9691	name,
	9692	}, &[_]u32{
	9693	try astgen.errNoteNode(decl_node, "declared here", .{}),
	9694	});
	9695	},
	9696	.gen_zir => s = s.cast(GenZir).?.parent,
	9697	.defer_normal, .defer_error => s = s.cast(Scope.Defer).?.parent,
	9698	.top => break,
	9699	};
	9700	}
	9701
9561	9702	fn advanceSourceCursor(astgen: *AstGen, source: []const u8, end: usize) void {
9562	9703	var i = astgen.source_offset;
9563	9704	var line = astgen.source_line;

src/Compilation.zig+87-31

...	...	@@ -670,6 +670,7 @@ pub const InitOptions = struct {
670	670	use_llvm: ?bool = null,
671	671	use_lld: ?bool = null,
672	672	use_clang: ?bool = null,
	673	use_stage1: ?bool = null,
673	674	rdynamic: bool = false,
674	675	strip: bool = false,
675	676	single_threaded: bool = false,
...	...	@@ -807,8 +808,22 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {
807	808
808	809	const ofmt = options.object_format orelse options.target.getObjectFormat();
809	810
	811	const use_stage1 = options.use_stage1 orelse blk: {
	812	if (build_options.omit_stage2)
	813	break :blk true;
	814	if (options.use_llvm) \|use_llvm\| {
	815	if (!use_llvm) {
	816	break :blk false;
	817	}
	818	}
	819	break :blk build_options.is_stage1;
	820	};
	821
810	822	// Make a decision on whether to use LLVM or our own backend.
811		const use_llvm = if (options.use_llvm) \|explicit\| explicit else blk: {
	823	const use_llvm = build_options.have_llvm and blk: {
	824	if (options.use_llvm) \|explicit\|
	825	break :blk explicit;
	826
812	827	// If we have no zig code to compile, no need for LLVM.
813	828	if (options.root_pkg == null)
814	829	break :blk false;
...	...	@@ -817,18 +832,24 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {
817	832	if (ofmt == .c)
818	833	break :blk false;
819	834
820		// If we are the stage1 compiler, we depend on the stage1 c++ llvm backend
	835	// The stage1 compiler depends on the stage1 C++ LLVM backend
821	836	// to compile zig code.
822		if (build_options.is_stage1)
	837	if (use_stage1)
	838	break :blk true;
	839
	840	// Prefer LLVM for release builds as long as it supports the target architecture.
	841	if (options.optimize_mode != .Debug and target_util.hasLlvmSupport(options.target))
823	842	break :blk true;
824	843
825		// We would want to prefer LLVM for release builds when it is available, however
826		// we don't have an LLVM backend yet :)
827		// We would also want to prefer LLVM for architectures that we don't have self-hosted support for too.
828	844	break :blk false;
829	845	};
830		if (!use_llvm and options.machine_code_model != .default) {
831		return error.MachineCodeModelNotSupported;
	846	if (!use_llvm) {
	847	if (options.use_llvm == true) {
	848	return error.ZigCompilerNotBuiltWithLLVMExtensions;
	849	}
	850	if (options.machine_code_model != .default) {
	851	return error.MachineCodeModelNotSupportedWithoutLlvm;
	852	}
832	853	}
833	854
834	855	const tsan = options.want_tsan orelse false;
...	...	@@ -1344,6 +1365,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {
1344	1365	.subsystem = options.subsystem,
1345	1366	.is_test = options.is_test,
1346	1367	.wasi_exec_model = wasi_exec_model,
	1368	.use_stage1 = use_stage1,
1347	1369	});
1348	1370	errdefer bin_file.destroy();
1349	1371	comp.* = .{
...	...	@@ -1486,9 +1508,9 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {
1486	1508	try comp.work_queue.writeItem(.libtsan);
1487	1509	}
1488	1510
1489		// The `is_stage1` condition is here only because stage2 cannot yet build compiler-rt.
	1511	// The `use_stage1` condition is here only because stage2 cannot yet build compiler-rt.
1490	1512	// Once it is capable this condition should be removed.
1491		if (build_options.is_stage1) {
	1513	if (comp.bin_file.options.use_stage1) {
1492	1514	if (comp.bin_file.options.include_compiler_rt) {
1493	1515	if (is_exe_or_dyn_lib) {
1494	1516	try comp.work_queue.writeItem(.{ .compiler_rt_lib = {} });
...	...	@@ -1519,7 +1541,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {
1519	1541	}
1520	1542	}
1521	1543
1522		if (build_options.is_stage1 and comp.bin_file.options.use_llvm) {
	1544	if (comp.bin_file.options.use_stage1 and comp.bin_file.options.module != null) {
1523	1545	try comp.work_queue.writeItem(.{ .stage1_module = {} });
1524	1546	}
1525	1547
...	...	@@ -1625,8 +1647,7 @@ pub fn update(self: *Compilation) !void {
1625	1647	self.c_object_work_queue.writeItemAssumeCapacity(key);
1626	1648	}
1627	1649
1628		const use_stage1 = build_options.omit_stage2 or
1629		(build_options.is_stage1 and self.bin_file.options.use_llvm);
	1650	const use_stage1 = build_options.is_stage1 and self.bin_file.options.use_stage1;
1630	1651	if (self.bin_file.options.module) \|module\| {
1631	1652	module.compile_log_text.shrinkAndFree(module.gpa, 0);
1632	1653	module.generation += 1;
...	...	@@ -1921,7 +1942,7 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
1921	1942	// (at least for now) single-threaded main work queue. However, C object compilation
1922	1943	// only needs to be finished by the end of this function.
1923	1944
1924		var zir_prog_node = main_progress_node.start("AST Lowering", self.astgen_work_queue.count);
	1945	var zir_prog_node = main_progress_node.start("AST Lowering", 0);
1925	1946	defer zir_prog_node.end();
1926	1947
1927	1948	var c_obj_prog_node = main_progress_node.start("Compile C Objects", self.c_source_files.len);
...	...	@@ -1937,7 +1958,7 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
1937	1958	while (self.astgen_work_queue.readItem()) \|file\| {
1938	1959	self.astgen_wait_group.start();
1939	1960	try self.thread_pool.spawn(workerAstGenFile, .{
1940		self, file, &zir_prog_node, &self.astgen_wait_group,
	1961	self, file, &zir_prog_node, &self.astgen_wait_group, .root,
1941	1962	});
1942	1963	}
1943	1964
...	...	@@ -1949,13 +1970,18 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
1949	1970	}
1950	1971	}
1951	1972
1952		const use_stage1 = build_options.omit_stage2 or
1953		(build_options.is_stage1 and self.bin_file.options.use_llvm);
	1973	const use_stage1 = build_options.is_stage1 and self.bin_file.options.use_stage1;
1954	1974	if (!use_stage1) {
1955	1975	// Iterate over all the files and look for outdated and deleted declarations.
1956	1976	if (self.bin_file.options.module) \|mod\| {
1957	1977	try mod.processOutdatedAndDeletedDecls();
1958	1978	}
	1979	} else if (self.bin_file.options.module) \|mod\| {
	1980	// If there are any AstGen compile errors, report them now to avoid
	1981	// hitting stage1 bugs.
	1982	if (mod.failed_files.count() != 0) {
	1983	return;
	1984	}
1959	1985	}
1960	1986
1961	1987	while (self.work_queue.readItem()) \|work_item\| switch (work_item) {
...	...	@@ -2284,11 +2310,20 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
2284	2310	};
2285	2311	}
2286	2312
	2313	const AstGenSrc = union(enum) {
	2314	root,
	2315	import: struct {
	2316	importing_file: *Module.Scope.File,
	2317	import_inst: Zir.Inst.Index,
	2318	},
	2319	};
	2320
2287	2321	fn workerAstGenFile(
2288	2322	comp: *Compilation,
2289	2323	file: *Module.Scope.File,
2290	2324	prog_node: *std.Progress.Node,
2291	2325	wg: *WaitGroup,
	2326	src: AstGenSrc,
2292	2327	) void {
2293	2328	defer wg.finish();
2294	2329
...	...	@@ -2301,7 +2336,7 @@ fn workerAstGenFile(
2301	2336	error.AnalysisFail => return,
2302	2337	else => {
2303	2338	file.status = .retryable_failure;
2304		comp.reportRetryableAstGenError(file, err) catch \|oom\| switch (oom) {
	2339	comp.reportRetryableAstGenError(src, file, err) catch \|oom\| switch (oom) {
2305	2340	// Swallowing this error is OK because it's implied to be OOM when
2306	2341	// there is a missing `failed_files` error message.
2307	2342	error.OutOfMemory => {},
...	...	@@ -2318,8 +2353,9 @@ fn workerAstGenFile(
2318	2353	if (imports_index != 0) {
2319	2354	const imports_len = file.zir.extra[imports_index];
2320	2355
2321		for (file.zir.extra[imports_index + 1 ..][0..imports_len]) \|str_index\| {
2322		const import_path = file.zir.nullTerminatedString(str_index);
	2356	for (file.zir.extra[imports_index + 1 ..][0..imports_len]) \|import_inst\| {
	2357	const inst_data = file.zir.instructions.items(.data)[import_inst].str_tok;
	2358	const import_path = inst_data.get(file.zir);
2323	2359
2324	2360	const import_result = blk: {
2325	2361	const lock = comp.mutex.acquire();
...	...	@@ -2331,9 +2367,13 @@ fn workerAstGenFile(
2331	2367	log.debug("AstGen of {s} has import '{s}'; queuing AstGen of {s}", .{
2332	2368	file.sub_file_path, import_path, import_result.file.sub_file_path,
2333	2369	});
	2370	const sub_src: AstGenSrc = .{ .import = .{
	2371	.importing_file = file,
	2372	.import_inst = import_inst,
	2373	} };
2334	2374	wg.start();
2335	2375	comp.thread_pool.spawn(workerAstGenFile, .{
2336		comp, import_result.file, prog_node, wg,
	2376	comp, import_result.file, prog_node, wg, sub_src,
2337	2377	}) catch {
2338	2378	wg.finish();
2339	2379	continue;
...	...	@@ -2544,6 +2584,7 @@ fn reportRetryableCObjectError(
2544	2584
2545	2585	fn reportRetryableAstGenError(
2546	2586	comp: *Compilation,
	2587	src: AstGenSrc,
2547	2588	file: *Module.Scope.File,
2548	2589	err: anyerror,
2549	2590	) error{OutOfMemory}!void {
...	...	@@ -2552,22 +2593,38 @@ fn reportRetryableAstGenError(
2552	2593
2553	2594	file.status = .retryable_failure;
2554	2595
2555		const src_loc: Module.SrcLoc = .{
2556		.file_scope = file,
2557		.parent_decl_node = 0,
2558		.lazy = .entire_file,
	2596	const src_loc: Module.SrcLoc = switch (src) {
	2597	.root => .{
	2598	.file_scope = file,
	2599	.parent_decl_node = 0,
	2600	.lazy = .entire_file,
	2601	},
	2602	.import => \|info\| blk: {
	2603	const importing_file = info.importing_file;
	2604	const import_inst = info.import_inst;
	2605	const inst_data = importing_file.zir.instructions.items(.data)[import_inst].str_tok;
	2606	break :blk .{
	2607	.file_scope = importing_file,
	2608	.parent_decl_node = 0,
	2609	.lazy = .{ .token_offset = inst_data.src_tok },
	2610	};
	2611	},
2559	2612	};
2560	2613
2561	2614	const err_msg = if (file.pkg.root_src_directory.path) \|dir_path\|
2562	2615	try Module.ErrorMsg.create(
2563	2616	gpa,
2564	2617	src_loc,
2565		"unable to load {s}" ++ std.fs.path.sep_str ++ "{s}: {s}",
2566		.{ dir_path, file.sub_file_path, @errorName(err) },
	2618	"unable to load '{'}" ++ std.fs.path.sep_str ++ "{'}': {s}",
	2619	.{
	2620	std.zig.fmtEscapes(dir_path),
	2621	std.zig.fmtEscapes(file.sub_file_path),
	2622	@errorName(err),
	2623	},
2567	2624	)
2568	2625	else
2569		try Module.ErrorMsg.create(gpa, src_loc, "unable to load {s}: {s}", .{
2570		file.sub_file_path, @errorName(err),
	2626	try Module.ErrorMsg.create(gpa, src_loc, "unable to load '{'}': {s}", .{
	2627	std.zig.fmtEscapes(file.sub_file_path), @errorName(err),
2571	2628	});
2572	2629	errdefer err_msg.destroy(gpa);
2573	2630
...	...	@@ -3486,8 +3543,7 @@ pub fn generateBuiltinZigSource(comp: Compilation, allocator: Allocator) Alloc
3486	3543
3487	3544	const target = comp.getTarget();
3488	3545	const generic_arch_name = target.cpu.arch.genericName();
3489		const use_stage1 = build_options.omit_stage2 or
3490		(build_options.is_stage1 and comp.bin_file.options.use_llvm);
	3546	const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
3491	3547
3492	3548	@setEvalBranchQuota(4000);
3493	3549	try buffer.writer().print(

src/Module.zig+10

...	...	@@ -2466,6 +2466,7 @@ pub fn astGenFile(mod: Module, file: Scope.File) !void {
2466	2466	defer msg.deinit();
2467	2467
2468	2468	const token_starts = file.tree.tokens.items(.start);
	2469	const token_tags = file.tree.tokens.items(.tag);
2469	2470
2470	2471	try file.tree.renderError(parse_err, msg.writer());
2471	2472	const err_msg = try gpa.create(ErrorMsg);
...	...	@@ -2477,6 +2478,15 @@ pub fn astGenFile(mod: Module, file: Scope.File) !void {
2477	2478	},
2478	2479	.msg = msg.toOwnedSlice(),
2479	2480	};
	2481	if (token_tags[parse_err.token] == .invalid) {
	2482	const bad_off = @intCast(u32, file.tree.tokenSlice(parse_err.token).len);
	2483	const byte_abs = token_starts[parse_err.token] + bad_off;
	2484	try mod.errNoteNonLazy(.{
	2485	.file_scope = file,
	2486	.parent_decl_node = 0,
	2487	.lazy = .{ .byte_abs = byte_abs },
	2488	}, err_msg, "invalid byte: '{'}'", .{std.zig.fmtEscapes(source[byte_abs..][0..1])});
	2489	}
2480	2490
2481	2491	{
2482	2492	const lock = comp.mutex.acquire();

src/Zir.zig+12-5

...	...	@@ -139,9 +139,15 @@ pub fn renderAsTextToFile(
139	139	if (imports_index != 0) {
140	140	try fs_file.writeAll("Imports:\n");
141	141	const imports_len = scope_file.zir.extra[imports_index];
142		for (scope_file.zir.extra[imports_index + 1 ..][0..imports_len]) \|str_index\| {
143		const import_path = scope_file.zir.nullTerminatedString(str_index);
144		try fs_file.writer().print(" {s}\n", .{import_path});
	142	for (scope_file.zir.extra[imports_index + 1 ..][0..imports_len]) \|import_inst\| {
	143	const inst_data = writer.code.instructions.items(.data)[import_inst].str_tok;
	144	const src = inst_data.src();
	145	const import_path = inst_data.get(writer.code);
	146	try fs_file.writer().print(" @import(\"{}\") ", .{
	147	std.zig.fmtEscapes(import_path),
	148	});
	149	try writer.writeSrc(fs_file.writer(), src);
	150	try fs_file.writer().writeAll("\n");
145	151	}
146	152	}
147	153	}
...	...	@@ -2767,9 +2773,10 @@ pub const Inst = struct {
2767	2773	};
2768	2774	};
2769	2775
2770		/// Trailing: for each `imports_len` there is a string table index.
	2776	/// Trailing: for each `imports_len` there is an instruction index
	2777	/// to an import instruction.
2771	2778	pub const Imports = struct {
2772		imports_len: u32,
	2779	imports_len: Zir.Inst.Index,
2773	2780	};
2774	2781	};
2775	2782

src/link.zig+3-2

...	...	@@ -92,6 +92,7 @@ pub const Options = struct {
92	92	each_lib_rpath: bool,
93	93	disable_lld_caching: bool,
94	94	is_test: bool,
	95	use_stage1: bool,
95	96	major_subsystem_version: ?u32,
96	97	minor_subsystem_version: ?u32,
97	98	gc_sections: ?bool = null,
...	...	@@ -181,7 +182,7 @@ pub const File = struct {
181	182	/// rewriting it. A malicious file is detected as incremental link failure
182	183	/// and does not cause Illegal Behavior. This operation is not atomic.
183	184	pub fn openPath(allocator: Allocator, options: Options) !File {
184		const use_stage1 = build_options.is_stage1 and options.use_llvm;
	185	const use_stage1 = build_options.is_stage1 and options.use_stage1;
185	186	if (use_stage1 or options.emit == null) {
186	187	return switch (options.object_format) {
187	188	.coff, .pe => &(try Coff.createEmpty(allocator, options)).base,
...	...	@@ -507,7 +508,7 @@ pub const File = struct {
507	508	// If there is no Zig code to compile, then we should skip flushing the output file because it
508	509	// will not be part of the linker line anyway.
509	510	const module_obj_path: ?[]const u8 = if (base.options.module) \|module\| blk: {
510		const use_stage1 = build_options.is_stage1 and base.options.use_llvm;
	511	const use_stage1 = build_options.is_stage1 and base.options.use_stage1;
511	512	if (use_stage1) {
512	513	const obj_basename = try std.zig.binNameAlloc(arena, .{
513	514	.root_name = base.options.root_name,

src/link/MachO.zig+1-1

...	...	@@ -606,7 +606,7 @@ fn linkWithZld(self: MachO, comp: Compilation) !void {
606	606	// If there is no Zig code to compile, then we should skip flushing the output file because it
607	607	// will not be part of the linker line anyway.
608	608	const module_obj_path: ?[]const u8 = if (self.base.options.module) \|module\| blk: {
609		const use_stage1 = build_options.is_stage1 and self.base.options.use_llvm;
	609	const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1;
610	610	if (use_stage1) {
611	611	const obj_basename = try std.zig.binNameAlloc(arena, .{
612	612	.root_name = self.base.options.root_name,

src/link/Wasm.zig+1-1

...	...	@@ -556,7 +556,7 @@ fn linkWithLLD(self: Wasm, comp: Compilation) !void {
556	556	// If there is no Zig code to compile, then we should skip flushing the output file because it
557	557	// will not be part of the linker line anyway.
558	558	const module_obj_path: ?[]const u8 = if (self.base.options.module) \|module\| blk: {
559		const use_stage1 = build_options.is_stage1 and self.base.options.use_llvm;
	559	const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1;
560	560	if (use_stage1) {
561	561	const obj_basename = try std.zig.binNameAlloc(arena, .{
562	562	.root_name = self.base.options.root_name,

src/main.zig+42-8

...	...	@@ -233,7 +233,7 @@ pub fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !v
233	233	} else if (mem.eql(u8, cmd, "build")) {
234	234	return cmdBuild(gpa, arena, cmd_args);
235	235	} else if (mem.eql(u8, cmd, "fmt")) {
236		return cmdFmt(gpa, cmd_args);
	236	return cmdFmt(gpa, arena, cmd_args);
237	237	} else if (mem.eql(u8, cmd, "libc")) {
238	238	return cmdLibC(gpa, cmd_args);
239	239	} else if (mem.eql(u8, cmd, "init-exe")) {
...	...	@@ -350,9 +350,11 @@ const usage_build_generic =
350	350	\\ -funwind-tables Always produce unwind table entries for all functions
351	351	\\ -fno-unwind-tables Never produce unwind table entries
352	352	\\ -fLLVM Force using LLVM as the codegen backend
353		\\ -fno-LLVM Prevent using LLVM as a codegen backend
	353	\\ -fno-LLVM Prevent using LLVM as the codegen backend
354	354	\\ -fClang Force using Clang as the C/C++ compilation backend
355	355	\\ -fno-Clang Prevent using Clang as the C/C++ compilation backend
	356	\\ -fstage1 Force using bootstrap compiler as the codegen backend
	357	\\ -fno-stage1 Prevent using bootstrap compiler as the codegen backend
356	358	\\ --strip Omit debug symbols
357	359	\\ --single-threaded Code assumes it is only used single-threaded
358	360	\\ -ofmt=[mode] Override target object format
...	...	@@ -602,6 +604,7 @@ fn buildOutputType(
602	604	var use_llvm: ?bool = null;
603	605	var use_lld: ?bool = null;
604	606	var use_clang: ?bool = null;
	607	var use_stage1: ?bool = null;
605	608	var link_eh_frame_hdr = false;
606	609	var link_emit_relocs = false;
607	610	var each_lib_rpath: ?bool = null;
...	...	@@ -975,6 +978,10 @@ fn buildOutputType(
975	978	use_clang = true;
976	979	} else if (mem.eql(u8, arg, "-fno-Clang")) {
977	980	use_clang = false;
	981	} else if (mem.eql(u8, arg, "-fstage1")) {
	982	use_stage1 = true;
	983	} else if (mem.eql(u8, arg, "-fno-stage1")) {
	984	use_stage1 = false;
978	985	} else if (mem.eql(u8, arg, "-rdynamic")) {
979	986	rdynamic = true;
980	987	} else if (mem.eql(u8, arg, "-fsoname")) {
...	...	@@ -2020,6 +2027,7 @@ fn buildOutputType(
2020	2027	.use_llvm = use_llvm,
2021	2028	.use_lld = use_lld,
2022	2029	.use_clang = use_clang,
	2030	.use_stage1 = use_stage1,
2023	2031	.rdynamic = rdynamic,
2024	2032	.linker_script = linker_script,
2025	2033	.version_script = version_script,
...	...	@@ -3031,12 +3039,13 @@ const Fmt = struct {
3031	3039	check_ast: bool,
3032	3040	color: Color,
3033	3041	gpa: *Allocator,
	3042	arena: *Allocator,
3034	3043	out_buffer: std.ArrayList(u8),
3035	3044
3036	3045	const SeenMap = std.AutoHashMap(fs.File.INode, void);
3037	3046	};
3038	3047
3039		pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
	3048	pub fn cmdFmt(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
3040	3049	var color: Color = .auto;
3041	3050	var stdin_flag: bool = false;
3042	3051	var check_flag: bool = false;
...	...	@@ -3094,7 +3103,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
3094	3103	defer tree.deinit(gpa);
3095	3104
3096	3105	for (tree.errors) \|parse_error\| {
3097		try printErrMsgToStdErr(gpa, parse_error, tree, "<stdin>", color);
	3106	try printErrMsgToStdErr(gpa, arena, parse_error, tree, "<stdin>", color);
3098	3107	}
3099	3108	var has_ast_error = false;
3100	3109	if (check_ast_flag) {
...	...	@@ -3162,6 +3171,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
3162	3171
3163	3172	var fmt = Fmt{
3164	3173	.gpa = gpa,
	3174	.arena = arena,
3165	3175	.seen = Fmt.SeenMap.init(gpa),
3166	3176	.any_error = false,
3167	3177	.check_ast = check_ast_flag,
...	...	@@ -3285,7 +3295,7 @@ fn fmtPathFile(
3285	3295	defer tree.deinit(fmt.gpa);
3286	3296
3287	3297	for (tree.errors) \|parse_error\| {
3288		try printErrMsgToStdErr(fmt.gpa, parse_error, tree, file_path, fmt.color);
	3298	try printErrMsgToStdErr(fmt.gpa, fmt.arena, parse_error, tree, file_path, fmt.color);
3289	3299	}
3290	3300	if (tree.errors.len != 0) {
3291	3301	fmt.any_error = true;
...	...	@@ -3366,12 +3376,14 @@ fn fmtPathFile(
3366	3376
3367	3377	fn printErrMsgToStdErr(
3368	3378	gpa: *mem.Allocator,
	3379	arena: *mem.Allocator,
3369	3380	parse_error: ast.Error,
3370	3381	tree: ast.Tree,
3371	3382	path: []const u8,
3372	3383	color: Color,
3373	3384	) !void {
3374	3385	const lok_token = parse_error.token;
	3386	const token_tags = tree.tokens.items(.tag);
3375	3387	const start_loc = tree.tokenLocation(0, lok_token);
3376	3388	const source_line = tree.source[start_loc.line_start..start_loc.line_end];
3377	3389
...	...	@@ -3381,6 +3393,27 @@ fn printErrMsgToStdErr(
3381	3393	try tree.renderError(parse_error, writer);
3382	3394	const text = text_buf.items;
3383	3395
	3396	var notes_buffer: [1]Compilation.AllErrors.Message = undefined;
	3397	var notes_len: usize = 0;
	3398
	3399	if (token_tags[parse_error.token] == .invalid) {
	3400	const bad_off = @intCast(u32, tree.tokenSlice(parse_error.token).len);
	3401	const byte_offset = @intCast(u32, start_loc.line_start) + bad_off;
	3402	notes_buffer[notes_len] = .{
	3403	.src = .{
	3404	.src_path = path,
	3405	.msg = try std.fmt.allocPrint(arena, "invalid byte: '{'}'", .{
	3406	std.zig.fmtEscapes(tree.source[byte_offset..][0..1]),
	3407	}),
	3408	.byte_offset = byte_offset,
	3409	.line = @intCast(u32, start_loc.line),
	3410	.column = @intCast(u32, start_loc.column) + bad_off,
	3411	.source_line = source_line,
	3412	},
	3413	};
	3414	notes_len += 1;
	3415	}
	3416
3384	3417	const message: Compilation.AllErrors.Message = .{
3385	3418	.src = .{
3386	3419	.src_path = path,
...	...	@@ -3389,6 +3422,7 @@ fn printErrMsgToStdErr(
3389	3422	.line = @intCast(u32, start_loc.line),
3390	3423	.column = @intCast(u32, start_loc.column),
3391	3424	.source_line = source_line,
	3425	.notes = notes_buffer[0..notes_len],
3392	3426	},
3393	3427	};
3394	3428
...	...	@@ -3915,7 +3949,7 @@ pub fn cmdAstCheck(
3915	3949	defer file.tree.deinit(gpa);
3916	3950
3917	3951	for (file.tree.errors) \|parse_error\| {
3918		try printErrMsgToStdErr(gpa, parse_error, file.tree, file.sub_file_path, color);
	3952	try printErrMsgToStdErr(gpa, arena, parse_error, file.tree, file.sub_file_path, color);
3919	3953	}
3920	3954	if (file.tree.errors.len != 0) {
3921	3955	process.exit(1);
...	...	@@ -4041,7 +4075,7 @@ pub fn cmdChangelist(
4041	4075	defer file.tree.deinit(gpa);
4042	4076
4043	4077	for (file.tree.errors) \|parse_error\| {
4044		try printErrMsgToStdErr(gpa, parse_error, file.tree, old_source_file, .auto);
	4078	try printErrMsgToStdErr(gpa, arena, parse_error, file.tree, old_source_file, .auto);
4045	4079	}
4046	4080	if (file.tree.errors.len != 0) {
4047	4081	process.exit(1);
...	...	@@ -4080,7 +4114,7 @@ pub fn cmdChangelist(
4080	4114	defer new_tree.deinit(gpa);
4081	4115
4082	4116	for (new_tree.errors) \|parse_error\| {
4083		try printErrMsgToStdErr(gpa, parse_error, new_tree, new_source_file, .auto);
	4117	try printErrMsgToStdErr(gpa, arena, parse_error, new_tree, new_source_file, .auto);
4084	4118	}
4085	4119	if (new_tree.errors.len != 0) {
4086	4120	process.exit(1);

src/stage1.zig+9-4

...	...	@@ -7,6 +7,7 @@ const assert = std.debug.assert;
7	7	const mem = std.mem;
8	8	const CrossTarget = std.zig.CrossTarget;
9	9	const Target = std.Target;
	10	const builtin = @import("builtin");
10	11
11	12	const build_options = @import("build_options");
12	13	const stage2 = @import("main.zig");
...	...	@@ -16,16 +17,19 @@ const translate_c = @import("translate_c.zig");
16	17	const target_util = @import("target.zig");
17	18
18	19	comptime {
19		assert(std.builtin.link_libc);
	20	assert(builtin.link_libc);
20	21	assert(build_options.is_stage1);
21	22	assert(build_options.have_llvm);
22		_ = @import("compiler_rt");
	23	if (!builtin.is_test) {
	24	_ = @import("compiler_rt");
	25	@export(main, .{ .name = "main" });
	26	}
23	27	}
24	28
25	29	pub const log = stage2.log;
26	30	pub const log_level = stage2.log_level;
27	31
28		pub export fn main(argc: c_int, argv: [][:0]u8) c_int {
	32	pub fn main(argc: c_int, argv: [][:0]u8) callconv(.C) c_int {
29	33	std.os.argv = argv[0..@intCast(usize, argc)];
30	34
31	35	std.debug.maybeEnableSegfaultHandler();
...	...	@@ -41,7 +45,7 @@ pub export fn main(argc: c_int, argv: [][:0]u8) c_int {
41	45	for (args) \|*arg, i\| {
42	46	arg.* = mem.spanZ(argv[i]);
43	47	}
44		if (std.builtin.mode == .Debug) {
	48	if (builtin.mode == .Debug) {
45	49	stage2.mainArgs(gpa, arena, args) catch unreachable;
46	50	} else {
47	51	stage2.mainArgs(gpa, arena, args) catch \|err\| fatal("{s}", .{@errorName(err)});
...	...	@@ -147,6 +151,7 @@ pub const Module = extern struct {
147	151	}
148	152	};
149	153
	154	pub const os_init = zig_stage1_os_init;
150	155	extern fn zig_stage1_os_init() void;
151	156
152	157	pub const create = zig_stage1_create;

src/stage1/all_types.hpp-4

...	...	@@ -2733,10 +2733,6 @@ struct IrInstSrc {
2733	2733	IrInst base;
2734	2734
2735	2735	IrInstSrcId id;
2736		// true if this instruction was generated by zig and not from user code
2737		// this matters for the "unreachable code" compile error
2738		bool is_gen;
2739		bool is_noreturn;
2740	2736
2741	2737	// When analyzing IR, instructions that point to this instruction in the "old ir"
2742	2738	// can find the instruction that corresponds to this value in the "new ir"

src/stage1/analyze.cpp+3-3

...	...	@@ -3915,7 +3915,7 @@ static void add_top_level_decl(CodeGen g, ScopeDecls decls_scope, Tld *tld) {
3915	3915	}
3916	3916	}
3917	3917	ErrorMsg *msg = add_node_error(g, tld->source_node, buf_sprintf("redefinition of '%s'", buf_ptr(tld->name)));
3918		add_error_note(g, msg, other_tld->source_node, buf_sprintf("previous definition is here"));
	3918	add_error_note(g, msg, other_tld->source_node, buf_sprintf("previous definition here"));
3919	3919	return;
3920	3920	}
3921	3921
...	...	@@ -4176,7 +4176,7 @@ ZigVar add_variable(CodeGen g, AstNode source_node, Scope parent_scope, Buf
4176	4176	if (existing_var->var_type == nullptr \|\| !type_is_invalid(existing_var->var_type)) {
4177	4177	ErrorMsg *msg = add_node_error(g, source_node,
4178	4178	buf_sprintf("redeclaration of variable '%s'", buf_ptr(name)));
4179		add_error_note(g, msg, existing_var->decl_node, buf_sprintf("previous declaration is here"));
	4179	add_error_note(g, msg, existing_var->decl_node, buf_sprintf("previous declaration here"));
4180	4180	}
4181	4181	variable_entry->var_type = g->builtin_types.entry_invalid;
4182	4182	} else {
...	...	@@ -4205,7 +4205,7 @@ ZigVar add_variable(CodeGen g, AstNode source_node, Scope parent_scope, Buf
4205	4205	if (want_err_msg) {
4206	4206	ErrorMsg *msg = add_node_error(g, source_node,
4207	4207	buf_sprintf("redefinition of '%s'", buf_ptr(name)));
4208		add_error_note(g, msg, tld->source_node, buf_sprintf("previous definition is here"));
	4208	add_error_note(g, msg, tld->source_node, buf_sprintf("previous definition here"));
4209	4209	}
4210	4210	variable_entry->var_type = g->builtin_types.entry_invalid;
4211	4211	}

src/stage1/astgen.cpp+74-81

...	...	@@ -55,7 +55,17 @@ static ErrorMsg exec_add_error_node(CodeGen codegen, Stage1Zir *exec, AstNode
55	55
56	56
57	57	static bool instr_is_unreachable(IrInstSrc *instruction) {
58		return instruction->is_noreturn;
	58	switch (instruction->id) {
	59	case IrInstSrcIdCondBr:
	60	case IrInstSrcIdReturn:
	61	case IrInstSrcIdBr:
	62	case IrInstSrcIdUnreachable:
	63	case IrInstSrcIdSwitchBr:
	64	case IrInstSrcIdPanic:
	65	return true;
	66	default:
	67	return false;
	68	}
59	69	}
60	70
61	71	void destroy_instruction_src(IrInstSrc *inst) {
...	...	@@ -947,7 +957,6 @@ static IrInstSrc ir_build_cond_br(Stage1AstGen ag, Scope scope, AstNode sour
947	957	Stage1ZirBasicBlock then_block, Stage1ZirBasicBlock else_block, IrInstSrc *is_comptime)
948	958	{
949	959	IrInstSrcCondBr *inst = ir_build_instruction<IrInstSrcCondBr>(ag, scope, source_node);
950		inst->base.is_noreturn = true;
951	960	inst->condition = condition;
952	961	inst->then_block = then_block;
953	962	inst->else_block = else_block;
...	...	@@ -963,7 +972,6 @@ static IrInstSrc ir_build_cond_br(Stage1AstGen ag, Scope scope, AstNode sour
963	972
964	973	static IrInstSrc ir_build_return_src(Stage1AstGen ag, Scope scope, AstNode source_node, IrInstSrc *operand) {
965	974	IrInstSrcReturn *inst = ir_build_instruction<IrInstSrcReturn>(ag, scope, source_node);
966		inst->base.is_noreturn = true;
967	975	inst->operand = operand;
968	976
969	977	if (operand != nullptr) ir_ref_instruction(operand, ag->current_basic_block);
...	...	@@ -1303,7 +1311,6 @@ static IrInstSrc ir_build_br(Stage1AstGen ag, Scope scope, AstNode source_no
1303	1311	Stage1ZirBasicBlock dest_block, IrInstSrc is_comptime)
1304	1312	{
1305	1313	IrInstSrcBr *inst = ir_build_instruction<IrInstSrcBr>(ag, scope, source_node);
1306		inst->base.is_noreturn = true;
1307	1314	inst->dest_block = dest_block;
1308	1315	inst->is_comptime = is_comptime;
1309	1316
...	...	@@ -1418,7 +1425,6 @@ static IrInstSrc ir_build_container_init_fields(Stage1AstGen ag, Scope *scope,
1418	1425
1419	1426	static IrInstSrc ir_build_unreachable(Stage1AstGen ag, Scope scope, AstNode source_node) {
1420	1427	IrInstSrcUnreachable *inst = ir_build_instruction<IrInstSrcUnreachable>(ag, scope, source_node);
1421		inst->base.is_noreturn = true;
1422	1428	return &inst->base;
1423	1429	}
1424	1430
...	...	@@ -1718,7 +1724,6 @@ static IrInstSrcSwitchBr ir_build_switch_br_src(Stage1AstGen ag, Scope *scope,
1718	1724	IrInstSrc is_comptime, IrInstSrc switch_prongs_void)
1719	1725	{
1720	1726	IrInstSrcSwitchBr *instruction = ir_build_instruction<IrInstSrcSwitchBr>(ag, scope, source_node);
1721		instruction->base.is_noreturn = true;
1722	1727	instruction->target_value = target_value;
1723	1728	instruction->else_block = else_block;
1724	1729	instruction->case_count = case_count;
...	...	@@ -2439,7 +2444,6 @@ static IrInstSrc ir_build_decl_ref(Stage1AstGen ag, Scope scope, AstNode sou
2439	2444
2440	2445	static IrInstSrc ir_build_panic_src(Stage1AstGen ag, Scope scope, AstNode source_node, IrInstSrc *msg) {
2441	2446	IrInstSrcPanic *instruction = ir_build_instruction<IrInstSrcPanic>(ag, scope, source_node);
2442		instruction->base.is_noreturn = true;
2443	2447	instruction->msg = msg;
2444	2448
2445	2449	ir_ref_instruction(msg, ag->current_basic_block);
...	...	@@ -2557,7 +2561,6 @@ static IrInstSrc ir_build_reset_result(Stage1AstGen ag, Scope *scope, AstNode
2557	2561	{
2558	2562	IrInstSrcResetResult *instruction = ir_build_instruction<IrInstSrcResetResult>(ag, scope, source_node);
2559	2563	instruction->result_loc = result_loc;
2560		instruction->base.is_gen = true;
2561	2564
2562	2565	return &instruction->base;
2563	2566	}
...	...	@@ -2737,7 +2740,6 @@ static IrInstSrc ir_build_alloca_src(Stage1AstGen ag, Scope scope, AstNode s
2737	2740	IrInstSrc align, const char name_hint, IrInstSrc *is_comptime)
2738	2741	{
2739	2742	IrInstSrcAlloca *instruction = ir_build_instruction<IrInstSrcAlloca>(ag, scope, source_node);
2740		instruction->base.is_gen = true;
2741	2743	instruction->align = align;
2742	2744	instruction->name_hint = name_hint;
2743	2745	instruction->is_comptime = is_comptime;
...	...	@@ -2752,7 +2754,6 @@ static IrInstSrc ir_build_end_expr(Stage1AstGen ag, Scope scope, AstNode sou
2752	2754	IrInstSrc value, ResultLoc result_loc)
2753	2755	{
2754	2756	IrInstSrcEndExpr *instruction = ir_build_instruction<IrInstSrcEndExpr>(ag, scope, source_node);
2755		instruction->base.is_gen = true;
2756	2757	instruction->value = value;
2757	2758	instruction->result_loc = result_loc;
2758	2759
...	...	@@ -2885,11 +2886,6 @@ static void ir_count_defers(Stage1AstGen ag, Scope inner_scope, Scope *outer_s
2885	2886	}
2886	2887	}
2887	2888
2888		static IrInstSrc ir_mark_gen(IrInstSrc instruction) {
2889		instruction->is_gen = true;
2890		return instruction;
2891		}
2892
2893	2889	static bool astgen_defers_for_block(Stage1AstGen ag, Scope inner_scope, Scope outer_scope, bool is_noreturn, IrInstSrc *err_value) {
2894	2890	Scope *scope = inner_scope;
2895	2891	if (is_noreturn != nullptr) *is_noreturn = false;
...	...	@@ -2945,11 +2941,11 @@ static bool astgen_defers_for_block(Stage1AstGen ag, Scope inner_scope, Scope
2945	2941	if (defer_expr_value == ag->codegen->invalid_inst_src)
2946	2942	return ag->codegen->invalid_inst_src;
2947	2943
2948		if (defer_expr_value->is_noreturn) {
	2944	if (instr_is_unreachable(defer_expr_value)) {
2949	2945	if (is_noreturn != nullptr) *is_noreturn = true;
2950	2946	} else {
2951		ir_mark_gen(ir_build_check_statement_is_void(ag, defer_expr_scope, defer_expr_node,
2952		defer_expr_value));
	2947	ir_build_check_statement_is_void(ag, defer_expr_scope, defer_expr_node,
	2948	defer_expr_value);
2953	2949	}
2954	2950	scope = scope->parent;
2955	2951	continue;
...	...	@@ -3047,7 +3043,7 @@ static IrInstSrc astgen_return(Stage1AstGen ag, Scope scope, AstNode node, L
3047	3043	ir_build_end_expr(ag, scope, node, return_value, &result_loc_ret->base);
3048	3044	}
3049	3045
3050		ir_mark_gen(ir_build_add_implicit_return_type(ag, scope, node, return_value, result_loc_ret));
	3046	ir_build_add_implicit_return_type(ag, scope, node, return_value, result_loc_ret);
3051	3047
3052	3048	size_t defer_counts[2];
3053	3049	ir_count_defers(ag, scope, outer_scope, defer_counts);
...	...	@@ -3074,7 +3070,7 @@ static IrInstSrc astgen_return(Stage1AstGen ag, Scope scope, AstNode node, L
3074	3070	is_comptime = ir_build_test_comptime(ag, scope, node, is_err);
3075	3071	}
3076	3072
3077		ir_mark_gen(ir_build_cond_br(ag, scope, node, is_err, err_block, ok_block, is_comptime));
	3073	ir_build_cond_br(ag, scope, node, is_err, err_block, ok_block, is_comptime);
3078	3074	Stage1ZirBasicBlock *ret_stmt_block = ir_create_basic_block(ag, scope, "RetStmt");
3079	3075
3080	3076	ir_set_cursor_at_end_and_append_block(ag, err_block);
...	...	@@ -3112,12 +3108,12 @@ static IrInstSrc astgen_return(Stage1AstGen ag, Scope scope, AstNode node, L
3112	3108	} else {
3113	3109	is_comptime = ir_build_test_comptime(ag, scope, node, is_err_val);
3114	3110	}
3115		ir_mark_gen(ir_build_cond_br(ag, scope, node, is_err_val, return_block, continue_block, is_comptime));
	3111	ir_build_cond_br(ag, scope, node, is_err_val, return_block, continue_block, is_comptime);
3116	3112
3117	3113	ir_set_cursor_at_end_and_append_block(ag, return_block);
3118	3114	IrInstSrc *err_val_ptr = ir_build_unwrap_err_code_src(ag, scope, node, err_union_ptr);
3119	3115	IrInstSrc *err_val = ir_build_load_ptr(ag, scope, node, err_val_ptr);
3120		ir_mark_gen(ir_build_add_implicit_return_type(ag, scope, node, err_val, nullptr));
	3116	ir_build_add_implicit_return_type(ag, scope, node, err_val, nullptr);
3121	3117	IrInstSrcSpillBegin *spill_begin = ir_build_spill_begin_src(ag, scope, node, err_val,
3122	3118	SpillIdRetErrCode);
3123	3119	ResultLocReturn *result_loc_ret = heap::c_allocator.create<ResultLocReturn>();
...	...	@@ -3173,7 +3169,7 @@ ZigVar create_local_var(CodeGen codegen, AstNode node, Scope parent_scope,
3173	3169	if (existing_var->var_type == nullptr \|\| !type_is_invalid(existing_var->var_type)) {
3174	3170	ErrorMsg *msg = add_node_error(codegen, node,
3175	3171	buf_sprintf("redeclaration of variable '%s'", buf_ptr(name)));
3176		add_error_note(codegen, msg, existing_var->decl_node, buf_sprintf("previous declaration is here"));
	3172	add_error_note(codegen, msg, existing_var->decl_node, buf_sprintf("previous declaration here"));
3177	3173	}
3178	3174	variable_entry->var_type = codegen->builtin_types.entry_invalid;
3179	3175	} else {
...	...	@@ -3195,7 +3191,7 @@ ZigVar create_local_var(CodeGen codegen, AstNode node, Scope parent_scope,
3195	3191	if (want_err_msg) {
3196	3192	ErrorMsg *msg = add_node_error(codegen, node,
3197	3193	buf_sprintf("redefinition of '%s'", buf_ptr(name)));
3198		add_error_note(codegen, msg, tld->source_node, buf_sprintf("previous definition is here"));
	3194	add_error_note(codegen, msg, tld->source_node, buf_sprintf("previous definition here"));
3199	3195	}
3200	3196	variable_entry->var_type = codegen->builtin_types.entry_invalid;
3201	3197	}
...	...	@@ -3251,7 +3247,7 @@ static bool is_duplicate_label(CodeGen g, Scope scope, AstNode node, Buf nam
3251	3247	Buf this_block_name = scope->id == ScopeIdBlock ? ((ScopeBlock )scope)->name : ((ScopeLoop *)scope)->name;
3252	3248	if (this_block_name != nullptr && buf_eql_buf(name, this_block_name)) {
3253	3249	ErrorMsg *msg = add_node_error(g, node, buf_sprintf("redeclaration of label '%s'", buf_ptr(name)));
3254		add_error_note(g, msg, scope->source_node, buf_sprintf("previous declaration is here"));
	3250	add_error_note(g, msg, scope->source_node, buf_sprintf("previous declaration here"));
3255	3251	return true;
3256	3252	}
3257	3253	}
...	...	@@ -3338,7 +3334,7 @@ static IrInstSrc astgen_block(Stage1AstGen ag, Scope parent_scope, AstNode b
3338	3334	child_scope = decl_var_instruction->var->child_scope;
3339	3335	} else if (!is_continuation_unreachable) {
3340	3336	// this statement's value must be void
3341		ir_mark_gen(ir_build_check_statement_is_void(ag, child_scope, statement_node, statement_value));
	3337	ir_build_check_statement_is_void(ag, child_scope, statement_node, statement_value);
3342	3338	}
3343	3339	}
3344	3340
...	...	@@ -3364,7 +3360,7 @@ static IrInstSrc astgen_block(Stage1AstGen ag, Scope parent_scope, AstNode b
3364	3360	return ir_expr_wrap(ag, parent_scope, phi, result_loc);
3365	3361	} else {
3366	3362	incoming_blocks.append(ag->current_basic_block);
3367		IrInstSrc *else_expr_result = ir_mark_gen(ir_build_const_void(ag, parent_scope, block_node));
	3363	IrInstSrc *else_expr_result = ir_build_const_void(ag, parent_scope, block_node);
3368	3364
3369	3365	if (scope_block->peer_parent != nullptr) {
3370	3366	ResultLocPeer *peer_result = create_peer_result(scope_block->peer_parent);
...	...	@@ -3387,13 +3383,13 @@ static IrInstSrc astgen_block(Stage1AstGen ag, Scope parent_scope, AstNode b
3387	3383
3388	3384	IrInstSrc *result;
3389	3385	if (block_node->data.block.name != nullptr) {
3390		ir_mark_gen(ir_build_br(ag, parent_scope, block_node, scope_block->end_block, scope_block->is_comptime));
	3386	ir_build_br(ag, parent_scope, block_node, scope_block->end_block, scope_block->is_comptime);
3391	3387	ir_set_cursor_at_end_and_append_block(ag, scope_block->end_block);
3392	3388	IrInstSrc *phi = ir_build_phi(ag, parent_scope, block_node, incoming_blocks.length,
3393	3389	incoming_blocks.items, incoming_values.items, scope_block->peer_parent);
3394	3390	result = ir_expr_wrap(ag, parent_scope, phi, result_loc);
3395	3391	} else {
3396		IrInstSrc *void_inst = ir_mark_gen(ir_build_const_void(ag, child_scope, block_node));
	3392	IrInstSrc *void_inst = ir_build_const_void(ag, child_scope, block_node);
3397	3393	result = ir_lval_wrap(ag, parent_scope, void_inst, lval, result_loc);
3398	3394	}
3399	3395	if (!is_return_from_fn)
...	...	@@ -3402,14 +3398,14 @@ static IrInstSrc astgen_block(Stage1AstGen ag, Scope parent_scope, AstNode b
3402	3398	// no need for save_err_ret_addr because this cannot return error
3403	3399	// only generate unconditional defers
3404	3400
3405		ir_mark_gen(ir_build_add_implicit_return_type(ag, child_scope, block_node, result, nullptr));
	3401	ir_build_add_implicit_return_type(ag, child_scope, block_node, result, nullptr);
3406	3402	ResultLocReturn *result_loc_ret = heap::c_allocator.create<ResultLocReturn>();
3407	3403	result_loc_ret->base.id = ResultLocIdReturn;
3408	3404	ir_build_reset_result(ag, parent_scope, block_node, &result_loc_ret->base);
3409		ir_mark_gen(ir_build_end_expr(ag, parent_scope, block_node, result, &result_loc_ret->base));
	3405	ir_build_end_expr(ag, parent_scope, block_node, result, &result_loc_ret->base);
3410	3406	if (!astgen_defers_for_block(ag, child_scope, outer_block_scope, nullptr, nullptr))
3411	3407	return ag->codegen->invalid_inst_src;
3412		return ir_mark_gen(ir_build_return_src(ag, child_scope, result->base.source_node, result));
	3408	return ir_build_return_src(ag, child_scope, result->base.source_node, result);
3413	3409	}
3414	3410
3415	3411	static IrInstSrc astgen_bin_op_id(Stage1AstGen ag, Scope scope, AstNode node, IrBinOp op_id) {
...	...	@@ -3628,7 +3624,7 @@ static IrInstSrc astgen_orelse(Stage1AstGen ag, Scope parent_scope, AstNode
3628	3624	return ag->codegen->invalid_inst_src;
3629	3625	Stage1ZirBasicBlock *after_null_block = ag->current_basic_block;
3630	3626	if (!instr_is_unreachable(null_result))
3631		ir_mark_gen(ir_build_br(ag, parent_scope, node, end_block, is_comptime));
	3627	ir_build_br(ag, parent_scope, node, end_block, is_comptime);
3632	3628
3633	3629	ir_set_cursor_at_end_and_append_block(ag, ok_block);
3634	3630	IrInstSrc *unwrapped_ptr = ir_build_optional_unwrap_ptr(ag, parent_scope, node, maybe_ptr, false);
...	...	@@ -5395,7 +5391,7 @@ static IrInstSrc astgen_if_bool_expr(Stage1AstGen ag, Scope scope, AstNode n
5395	5391	return ag->codegen->invalid_inst_src;
5396	5392	Stage1ZirBasicBlock *after_then_block = ag->current_basic_block;
5397	5393	if (!instr_is_unreachable(then_expr_result))
5398		ir_mark_gen(ir_build_br(ag, scope, node, endif_block, is_comptime));
	5394	ir_build_br(ag, scope, node, endif_block, is_comptime);
5399	5395
5400	5396	ir_set_cursor_at_end_and_append_block(ag, else_block);
5401	5397	IrInstSrc *else_expr_result;
...	...	@@ -5409,7 +5405,7 @@ static IrInstSrc astgen_if_bool_expr(Stage1AstGen ag, Scope scope, AstNode n
5409	5405	}
5410	5406	Stage1ZirBasicBlock *after_else_block = ag->current_basic_block;
5411	5407	if (!instr_is_unreachable(else_expr_result))
5412		ir_mark_gen(ir_build_br(ag, scope, node, endif_block, is_comptime));
	5408	ir_build_br(ag, scope, node, endif_block, is_comptime);
5413	5409
5414	5410	ir_set_cursor_at_end_and_append_block(ag, endif_block);
5415	5411	IrInstSrc *incoming_values = heap::c_allocator.allocate<IrInstSrc >(2);
...	...	@@ -5954,12 +5950,11 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
5954	5950	IrInstSrc *is_err = ir_build_test_err_src(ag, scope, node->data.while_expr.condition, err_val_ptr,
5955	5951	true, false);
5956	5952	Stage1ZirBasicBlock *after_cond_block = ag->current_basic_block;
5957		IrInstSrc *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(ag, scope, node));
	5953	IrInstSrc *void_else_result = else_node ? nullptr : ir_build_const_void(ag, scope, node);
5958	5954	IrInstSrc *cond_br_inst;
5959	5955	if (!instr_is_unreachable(is_err)) {
5960	5956	cond_br_inst = ir_build_cond_br(ag, scope, node->data.while_expr.condition, is_err,
5961	5957	else_block, body_block, is_comptime);
5962		cond_br_inst->is_gen = true;
5963	5958	} else {
5964	5959	// for the purposes of the source instruction to ir_build_result_peers
5965	5960	cond_br_inst = ag->current_basic_block->instruction_list.last();
...	...	@@ -6005,8 +6000,8 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6005	6000	}
6006	6001
6007	6002	if (!instr_is_unreachable(body_result)) {
6008		ir_mark_gen(ir_build_check_statement_is_void(ag, payload_scope, node->data.while_expr.body, body_result));
6009		ir_mark_gen(ir_build_br(ag, payload_scope, node, continue_block, is_comptime));
	6003	ir_build_check_statement_is_void(ag, payload_scope, node->data.while_expr.body, body_result);
	6004	ir_build_br(ag, payload_scope, node, continue_block, is_comptime);
6010	6005	}
6011	6006
6012	6007	if (continue_expr_node) {
...	...	@@ -6015,8 +6010,8 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6015	6010	if (expr_result == ag->codegen->invalid_inst_src)
6016	6011	return expr_result;
6017	6012	if (!instr_is_unreachable(expr_result)) {
6018		ir_mark_gen(ir_build_check_statement_is_void(ag, payload_scope, continue_expr_node, expr_result));
6019		ir_mark_gen(ir_build_br(ag, payload_scope, node, cond_block, is_comptime));
	6013	ir_build_check_statement_is_void(ag, payload_scope, continue_expr_node, expr_result);
	6014	ir_build_br(ag, payload_scope, node, cond_block, is_comptime);
6020	6015	}
6021	6016	}
6022	6017
...	...	@@ -6041,7 +6036,7 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6041	6036	if (else_result == ag->codegen->invalid_inst_src)
6042	6037	return else_result;
6043	6038	if (!instr_is_unreachable(else_result))
6044		ir_mark_gen(ir_build_br(ag, scope, node, end_block, is_comptime));
	6039	ir_build_br(ag, scope, node, end_block, is_comptime);
6045	6040	Stage1ZirBasicBlock *after_else_block = ag->current_basic_block;
6046	6041	ir_set_cursor_at_end_and_append_block(ag, end_block);
6047	6042	if (else_result) {
...	...	@@ -6075,12 +6070,11 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6075	6070	IrInstSrc *maybe_val = ir_build_load_ptr(ag, scope, node->data.while_expr.condition, maybe_val_ptr);
6076	6071	IrInstSrc *is_non_null = ir_build_test_non_null_src(ag, scope, node->data.while_expr.condition, maybe_val);
6077	6072	Stage1ZirBasicBlock *after_cond_block = ag->current_basic_block;
6078		IrInstSrc *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(ag, scope, node));
	6073	IrInstSrc *void_else_result = else_node ? nullptr : ir_build_const_void(ag, scope, node);
6079	6074	IrInstSrc *cond_br_inst;
6080	6075	if (!instr_is_unreachable(is_non_null)) {
6081	6076	cond_br_inst = ir_build_cond_br(ag, scope, node->data.while_expr.condition, is_non_null,
6082	6077	body_block, else_block, is_comptime);
6083		cond_br_inst->is_gen = true;
6084	6078	} else {
6085	6079	// for the purposes of the source instruction to ir_build_result_peers
6086	6080	cond_br_inst = ag->current_basic_block->instruction_list.last();
...	...	@@ -6123,8 +6117,8 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6123	6117	}
6124	6118
6125	6119	if (!instr_is_unreachable(body_result)) {
6126		ir_mark_gen(ir_build_check_statement_is_void(ag, child_scope, node->data.while_expr.body, body_result));
6127		ir_mark_gen(ir_build_br(ag, child_scope, node, continue_block, is_comptime));
	6120	ir_build_check_statement_is_void(ag, child_scope, node->data.while_expr.body, body_result);
	6121	ir_build_br(ag, child_scope, node, continue_block, is_comptime);
6128	6122	}
6129	6123
6130	6124	if (continue_expr_node) {
...	...	@@ -6133,8 +6127,8 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6133	6127	if (expr_result == ag->codegen->invalid_inst_src)
6134	6128	return expr_result;
6135	6129	if (!instr_is_unreachable(expr_result)) {
6136		ir_mark_gen(ir_build_check_statement_is_void(ag, child_scope, continue_expr_node, expr_result));
6137		ir_mark_gen(ir_build_br(ag, child_scope, node, cond_block, is_comptime));
	6130	ir_build_check_statement_is_void(ag, child_scope, continue_expr_node, expr_result);
	6131	ir_build_br(ag, child_scope, node, cond_block, is_comptime);
6138	6132	}
6139	6133	}
6140	6134
...	...	@@ -6151,7 +6145,7 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6151	6145	if (else_result == ag->codegen->invalid_inst_src)
6152	6146	return else_result;
6153	6147	if (!instr_is_unreachable(else_result))
6154		ir_mark_gen(ir_build_br(ag, scope, node, end_block, is_comptime));
	6148	ir_build_br(ag, scope, node, end_block, is_comptime);
6155	6149	}
6156	6150	Stage1ZirBasicBlock *after_else_block = ag->current_basic_block;
6157	6151	ir_set_cursor_at_end_and_append_block(ag, end_block);
...	...	@@ -6175,12 +6169,11 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6175	6169	if (cond_val == ag->codegen->invalid_inst_src)
6176	6170	return cond_val;
6177	6171	Stage1ZirBasicBlock *after_cond_block = ag->current_basic_block;
6178		IrInstSrc *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(ag, scope, node));
	6172	IrInstSrc *void_else_result = else_node ? nullptr : ir_build_const_void(ag, scope, node);
6179	6173	IrInstSrc *cond_br_inst;
6180	6174	if (!instr_is_unreachable(cond_val)) {
6181	6175	cond_br_inst = ir_build_cond_br(ag, scope, node->data.while_expr.condition, cond_val,
6182	6176	body_block, else_block, is_comptime);
6183		cond_br_inst->is_gen = true;
6184	6177	} else {
6185	6178	// for the purposes of the source instruction to ir_build_result_peers
6186	6179	cond_br_inst = ag->current_basic_block->instruction_list.last();
...	...	@@ -6219,8 +6212,8 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6219	6212	}
6220	6213
6221	6214	if (!instr_is_unreachable(body_result)) {
6222		ir_mark_gen(ir_build_check_statement_is_void(ag, scope, node->data.while_expr.body, body_result));
6223		ir_mark_gen(ir_build_br(ag, scope, node, continue_block, is_comptime));
	6215	ir_build_check_statement_is_void(ag, scope, node->data.while_expr.body, body_result);
	6216	ir_build_br(ag, scope, node, continue_block, is_comptime);
6224	6217	}
6225	6218
6226	6219	if (continue_expr_node) {
...	...	@@ -6229,8 +6222,8 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6229	6222	if (expr_result == ag->codegen->invalid_inst_src)
6230	6223	return expr_result;
6231	6224	if (!instr_is_unreachable(expr_result)) {
6232		ir_mark_gen(ir_build_check_statement_is_void(ag, scope, continue_expr_node, expr_result));
6233		ir_mark_gen(ir_build_br(ag, scope, node, cond_block, is_comptime));
	6225	ir_build_check_statement_is_void(ag, scope, continue_expr_node, expr_result);
	6226	ir_build_br(ag, scope, node, cond_block, is_comptime);
6234	6227	}
6235	6228	}
6236	6229
...	...	@@ -6248,7 +6241,7 @@ static IrInstSrc astgen_while_expr(Stage1AstGen ag, Scope scope, AstNode nod
6248	6241	if (else_result == ag->codegen->invalid_inst_src)
6249	6242	return else_result;
6250	6243	if (!instr_is_unreachable(else_result))
6251		ir_mark_gen(ir_build_br(ag, scope, node, end_block, is_comptime));
	6244	ir_build_br(ag, scope, node, end_block, is_comptime);
6252	6245	}
6253	6246	Stage1ZirBasicBlock *after_else_block = ag->current_basic_block;
6254	6247	ir_set_cursor_at_end_and_append_block(ag, end_block);
...	...	@@ -6332,9 +6325,9 @@ static IrInstSrc astgen_for_expr(Stage1AstGen ag, Scope *parent_scope, AstNode
6332	6325	IrInstSrc *index_val = ir_build_load_ptr(ag, &spill_scope->base, node, index_ptr);
6333	6326	IrInstSrc *cond = ir_build_bin_op(ag, parent_scope, node, IrBinOpCmpLessThan, index_val, len_val, false);
6334	6327	Stage1ZirBasicBlock *after_cond_block = ag->current_basic_block;
6335		IrInstSrc *void_else_value = else_node ? nullptr : ir_mark_gen(ir_build_const_void(ag, parent_scope, node));
6336		IrInstSrc *cond_br_inst = ir_mark_gen(ir_build_cond_br(ag, parent_scope, node, cond,
6337		body_block, else_block, is_comptime));
	6328	IrInstSrc *void_else_value = else_node ? nullptr : ir_build_const_void(ag, parent_scope, node);
	6329	IrInstSrc *cond_br_inst = ir_build_cond_br(ag, parent_scope, node, cond,
	6330	body_block, else_block, is_comptime);
6338	6331
6339	6332	ResultLocPeerParent *peer_parent = ir_build_result_peers(ag, cond_br_inst, end_block, result_loc, is_comptime);
6340	6333
...	...	@@ -6377,8 +6370,8 @@ static IrInstSrc astgen_for_expr(Stage1AstGen ag, Scope *parent_scope, AstNode
6377	6370	}
6378	6371
6379	6372	if (!instr_is_unreachable(body_result)) {
6380		ir_mark_gen(ir_build_check_statement_is_void(ag, child_scope, node->data.for_expr.body, body_result));
6381		ir_mark_gen(ir_build_br(ag, child_scope, node, continue_block, is_comptime));
	6373	ir_build_check_statement_is_void(ag, child_scope, node->data.for_expr.body, body_result);
	6374	ir_build_br(ag, child_scope, node, continue_block, is_comptime);
6382	6375	}
6383	6376
6384	6377	ir_set_cursor_at_end_and_append_block(ag, continue_block);
...	...	@@ -6399,7 +6392,7 @@ static IrInstSrc astgen_for_expr(Stage1AstGen ag, Scope *parent_scope, AstNode
6399	6392	if (else_result == ag->codegen->invalid_inst_src)
6400	6393	return else_result;
6401	6394	if (!instr_is_unreachable(else_result))
6402		ir_mark_gen(ir_build_br(ag, parent_scope, node, end_block, is_comptime));
	6395	ir_build_br(ag, parent_scope, node, end_block, is_comptime);
6403	6396	}
6404	6397	Stage1ZirBasicBlock *after_else_block = ag->current_basic_block;
6405	6398	ir_set_cursor_at_end_and_append_block(ag, end_block);
...	...	@@ -6719,7 +6712,7 @@ static IrInstSrc astgen_if_optional_expr(Stage1AstGen ag, Scope *scope, AstNod
6719	6712	return then_expr_result;
6720	6713	Stage1ZirBasicBlock *after_then_block = ag->current_basic_block;
6721	6714	if (!instr_is_unreachable(then_expr_result))
6722		ir_mark_gen(ir_build_br(ag, scope, node, endif_block, is_comptime));
	6715	ir_build_br(ag, scope, node, endif_block, is_comptime);
6723	6716
6724	6717	ir_set_cursor_at_end_and_append_block(ag, else_block);
6725	6718	IrInstSrc *else_expr_result;
...	...	@@ -6733,7 +6726,7 @@ static IrInstSrc astgen_if_optional_expr(Stage1AstGen ag, Scope *scope, AstNod
6733	6726	}
6734	6727	Stage1ZirBasicBlock *after_else_block = ag->current_basic_block;
6735	6728	if (!instr_is_unreachable(else_expr_result))
6736		ir_mark_gen(ir_build_br(ag, scope, node, endif_block, is_comptime));
	6729	ir_build_br(ag, scope, node, endif_block, is_comptime);
6737	6730
6738	6731	ir_set_cursor_at_end_and_append_block(ag, endif_block);
6739	6732	IrInstSrc *incoming_values = heap::c_allocator.allocate<IrInstSrc >(2);
...	...	@@ -6802,7 +6795,7 @@ static IrInstSrc astgen_if_err_expr(Stage1AstGen ag, Scope scope, AstNode no
6802	6795	return then_expr_result;
6803	6796	Stage1ZirBasicBlock *after_then_block = ag->current_basic_block;
6804	6797	if (!instr_is_unreachable(then_expr_result))
6805		ir_mark_gen(ir_build_br(ag, scope, node, endif_block, is_comptime));
	6798	ir_build_br(ag, scope, node, endif_block, is_comptime);
6806	6799
6807	6800	ir_set_cursor_at_end_and_append_block(ag, else_block);
6808	6801
...	...	@@ -6831,7 +6824,7 @@ static IrInstSrc astgen_if_err_expr(Stage1AstGen ag, Scope scope, AstNode no
6831	6824	}
6832	6825	Stage1ZirBasicBlock *after_else_block = ag->current_basic_block;
6833	6826	if (!instr_is_unreachable(else_expr_result))
6834		ir_mark_gen(ir_build_br(ag, scope, node, endif_block, is_comptime));
	6827	ir_build_br(ag, scope, node, endif_block, is_comptime);
6835	6828
6836	6829	ir_set_cursor_at_end_and_append_block(ag, endif_block);
6837	6830	IrInstSrc *incoming_values = heap::c_allocator.allocate<IrInstSrc >(2);
...	...	@@ -6893,7 +6886,7 @@ static bool astgen_switch_prong_expr(Stage1AstGen ag, Scope scope, AstNode *sw
6893	6886	if (expr_result == ag->codegen->invalid_inst_src)
6894	6887	return false;
6895	6888	if (!instr_is_unreachable(expr_result))
6896		ir_mark_gen(ir_build_br(ag, scope, switch_node, end_block, is_comptime));
	6889	ir_build_br(ag, scope, switch_node, end_block, is_comptime);
6897	6890	incoming_blocks->append(ag->current_basic_block);
6898	6891	incoming_values->append(expr_result);
6899	6892	return true;
...	...	@@ -7008,8 +7001,8 @@ static IrInstSrc astgen_switch_expr(Stage1AstGen ag, Scope scope, AstNode no
7008	7001
7009	7002	assert(ok_bit);
7010	7003	assert(last_item_node);
7011		IrInstSrc *br_inst = ir_mark_gen(ir_build_cond_br(ag, scope, last_item_node, ok_bit,
7012		range_block_yes, range_block_no, is_comptime));
	7004	IrInstSrc *br_inst = ir_build_cond_br(ag, scope, last_item_node, ok_bit,
	7005	range_block_yes, range_block_no, is_comptime);
7013	7006	if (peer_parent->base.source_instruction == nullptr) {
7014	7007	peer_parent->base.source_instruction = br_inst;
7015	7008	}
...	...	@@ -7033,7 +7026,7 @@ static IrInstSrc astgen_switch_expr(Stage1AstGen ag, Scope scope, AstNode no
7033	7026	ErrorMsg *msg = add_node_error(ag->codegen, prong_node,
7034	7027	buf_sprintf("multiple else prongs in switch expression"));
7035	7028	add_error_note(ag->codegen, msg, else_prong,
7036		buf_sprintf("previous else prong is here"));
	7029	buf_sprintf("previous else prong here"));
7037	7030	return ag->codegen->invalid_inst_src;
7038	7031	}
7039	7032	else_prong = prong_node;
...	...	@@ -7044,7 +7037,7 @@ static IrInstSrc astgen_switch_expr(Stage1AstGen ag, Scope scope, AstNode no
7044	7037	ErrorMsg *msg = add_node_error(ag->codegen, prong_node,
7045	7038	buf_sprintf("multiple '_' prongs in switch expression"));
7046	7039	add_error_note(ag->codegen, msg, underscore_prong,
7047		buf_sprintf("previous '_' prong is here"));
	7040	buf_sprintf("previous '_' prong here"));
7048	7041	return ag->codegen->invalid_inst_src;
7049	7042	}
7050	7043	underscore_prong = prong_node;
...	...	@@ -7056,10 +7049,10 @@ static IrInstSrc astgen_switch_expr(Stage1AstGen ag, Scope scope, AstNode no
7056	7049	buf_sprintf("else and '_' prong in switch expression"));
7057	7050	if (underscore_prong == prong_node)
7058	7051	add_error_note(ag->codegen, msg, else_prong,
7059		buf_sprintf("else prong is here"));
	7052	buf_sprintf("else prong here"));
7060	7053	else
7061	7054	add_error_note(ag->codegen, msg, underscore_prong,
7062		buf_sprintf("'_' prong is here"));
	7055	buf_sprintf("'_' prong here"));
7063	7056	return ag->codegen->invalid_inst_src;
7064	7057	}
7065	7058	ResultLocPeer *this_peer_result_loc = create_peer_result(peer_parent);
...	...	@@ -7349,14 +7342,14 @@ static IrInstSrc astgen_continue(Stage1AstGen ag, Scope *continue_scope, AstNo
7349	7342
7350	7343	for (size_t i = 0; i < runtime_scopes.length; i += 1) {
7351	7344	ScopeRuntime *scope_runtime = runtime_scopes.at(i);
7352		ir_mark_gen(ir_build_check_runtime_scope(ag, continue_scope, node, scope_runtime->is_comptime, is_comptime));
	7345	ir_build_check_runtime_scope(ag, continue_scope, node, scope_runtime->is_comptime, is_comptime);
7353	7346	}
7354	7347	runtime_scopes.deinit();
7355	7348
7356	7349	Stage1ZirBasicBlock *dest_block = loop_scope->continue_block;
7357	7350	if (!astgen_defers_for_block(ag, continue_scope, dest_block->scope, nullptr, nullptr))
7358	7351	return ag->codegen->invalid_inst_src;
7359		return ir_mark_gen(ir_build_br(ag, continue_scope, node, dest_block, is_comptime));
	7352	return ir_build_br(ag, continue_scope, node, dest_block, is_comptime);
7360	7353	}
7361	7354
7362	7355	static IrInstSrc astgen_error_type(Stage1AstGen ag, Scope scope, AstNode node) {
...	...	@@ -7482,7 +7475,7 @@ static IrInstSrc astgen_catch(Stage1AstGen ag, Scope parent_scope, AstNode n
7482	7475	return ag->codegen->invalid_inst_src;
7483	7476	Stage1ZirBasicBlock *after_err_block = ag->current_basic_block;
7484	7477	if (!instr_is_unreachable(err_result))
7485		ir_mark_gen(ir_build_br(ag, parent_scope, node, end_block, is_comptime));
	7478	ir_build_br(ag, parent_scope, node, end_block, is_comptime);
7486	7479
7487	7480	ir_set_cursor_at_end_and_append_block(ag, ok_block);
7488	7481	IrInstSrc *unwrapped_ptr = ir_build_unwrap_err_payload_src(ag, parent_scope, node, err_union_ptr, false, false);
...	...	@@ -7757,9 +7750,9 @@ static IrInstSrc astgen_suspend(Stage1AstGen ag, Scope *parent_scope, AstNode
7757	7750	IrInstSrc *susp_res = astgen_node(ag, node->data.suspend.block, child_scope);
7758	7751	if (susp_res == ag->codegen->invalid_inst_src)
7759	7752	return ag->codegen->invalid_inst_src;
7760		ir_mark_gen(ir_build_check_statement_is_void(ag, child_scope, node->data.suspend.block, susp_res));
	7753	ir_build_check_statement_is_void(ag, child_scope, node->data.suspend.block, susp_res);
7761	7754
7762		return ir_mark_gen(ir_build_suspend_finish_src(ag, parent_scope, node, begin));
	7755	return ir_build_suspend_finish_src(ag, parent_scope, node, begin);
7763	7756	}
7764	7757
7765	7758	static IrInstSrc astgen_node_raw(Stage1AstGen ag, AstNode node, Scope scope,
...	...	@@ -8073,13 +8066,13 @@ bool stage1_astgen(CodeGen codegen, AstNode node, Scope scope, Stage1Zir sta
8073	8066	}
8074	8067
8075	8068	if (!instr_is_unreachable(result)) {
8076		ir_mark_gen(ir_build_add_implicit_return_type(ag, scope, result->base.source_node, result, nullptr));
	8069	ir_build_add_implicit_return_type(ag, scope, result->base.source_node, result, nullptr);
8077	8070	// no need for save_err_ret_addr because this cannot return error
8078	8071	ResultLocReturn *result_loc_ret = heap::c_allocator.create<ResultLocReturn>();
8079	8072	result_loc_ret->base.id = ResultLocIdReturn;
8080	8073	ir_build_reset_result(ag, scope, node, &result_loc_ret->base);
8081		ir_mark_gen(ir_build_end_expr(ag, scope, node, result, &result_loc_ret->base));
8082		ir_mark_gen(ir_build_return_src(ag, scope, result->base.source_node, result));
	8074	ir_build_end_expr(ag, scope, node, result, &result_loc_ret->base);
	8075	ir_build_return_src(ag, scope, result->base.source_node, result);
8083	8076	}
8084	8077
8085	8078	return true;

src/stage1/ir.cpp+9-19

...	...	@@ -5407,16 +5407,6 @@ static void ir_finish_bb(IrAnalyze *ira) {
5407	5407	ira->new_irb.current_basic_block->debug_id);
5408	5408	}
5409	5409	}
5410		ira->instruction_index += 1;
5411		while (ira->instruction_index < ira->zir_current_basic_block->instruction_list.length) {
5412		IrInstSrc *next_instruction = ira->zir_current_basic_block->instruction_list.at(ira->instruction_index);
5413		if (!next_instruction->is_gen) {
5414		ir_add_error(ira, &next_instruction->base, buf_sprintf("unreachable code"));
5415		break;
5416		}
5417		ira->instruction_index += 1;
5418		}
5419
5420	5410	ir_start_next_bb(ira);
5421	5411	}
5422	5412
...	...	@@ -11107,7 +11097,7 @@ static IrInstGen ir_analyze_instruction_export(IrAnalyze ira, IrInstSrcExport
11107	11097	AstNode *other_export_node = entry->value->source_node;
11108	11098	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
11109	11099	buf_sprintf("exported symbol collision: '%s'", buf_ptr(symbol_name)));
11110		add_error_note(ira->codegen, msg, other_export_node, buf_sprintf("other symbol is here"));
	11100	add_error_note(ira->codegen, msg, other_export_node, buf_sprintf("other symbol here"));
11111	11101	return ira->codegen->invalid_inst_gen;
11112	11102	}
11113	11103
...	...	@@ -11413,7 +11403,7 @@ static IrInstGen ir_analyze_instruction_extern(IrAnalyze ira, IrInstSrcExtern
11413	11403	AstNode *other_extern_node = entry->value->source_node;
11414	11404	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
11415	11405	buf_sprintf("extern symbol collision: '%s'", buf_ptr(symbol_name)));
11416		add_error_note(ira->codegen, msg, other_extern_node, buf_sprintf("other symbol is here"));
	11406	add_error_note(ira->codegen, msg, other_extern_node, buf_sprintf("other symbol here"));
11417	11407	return ira->codegen->invalid_inst_gen;
11418	11408	}
11419	11409
...	...	@@ -15934,7 +15924,7 @@ static IrInstGen ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstSrcPopC
15934	15924	return ir_build_pop_count_gen(ira, &instruction->base.base, return_type, op);
15935	15925	}
15936	15926
15937		static IrInstGen ir_analyze_union_tag(IrAnalyze ira, IrInst* source_instr, IrInstGen *value, bool is_gen) {
	15927	static IrInstGen ir_analyze_union_tag(IrAnalyze ira, IrInst* source_instr, IrInstGen *value) {
15938	15928	if (type_is_invalid(value->value->type))
15939	15929	return ira->codegen->invalid_inst_gen;
15940	15930
...	...	@@ -15943,7 +15933,7 @@ static IrInstGen ir_analyze_union_tag(IrAnalyze ira, IrInst* source_instr, IrI
15943	15933	buf_sprintf("expected enum or union type, found '%s'", buf_ptr(&value->value->type->name)));
15944	15934	return ira->codegen->invalid_inst_gen;
15945	15935	}
15946		if (!value->value->type->data.unionation.have_explicit_tag_type && !is_gen) {
	15936	if (!value->value->type->data.unionation.have_explicit_tag_type) {
15947	15937	ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("union has no associated enum"));
15948	15938	if (value->value->type->data.unionation.decl_node != nullptr) {
15949	15939	add_error_note(ira->codegen, msg, value->value->type->data.unionation.decl_node,
...	...	@@ -16906,7 +16896,7 @@ static IrInstGen ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrInstSrc
16906	16896	}
16907	16897
16908	16898	if (target_type->id == ZigTypeIdUnion) {
16909		target = ir_analyze_union_tag(ira, &instruction->base.base, target, instruction->base.is_gen);
	16899	target = ir_analyze_union_tag(ira, &instruction->base.base, target);
16910	16900	if (type_is_invalid(target->value->type))
16911	16901	return ira->codegen->invalid_inst_gen;
16912	16902	target_type = target->value->type;
...	...	@@ -21742,7 +21732,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21742	21732	ErrorMsg *msg = ir_add_error(ira, &start_value->base,
21743	21733	buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&switch_type->name),
21744	21734	buf_ptr(enum_field->name)));
21745		add_error_note(ira->codegen, msg, prev_node, buf_sprintf("other value is here"));
	21735	add_error_note(ira->codegen, msg, prev_node, buf_sprintf("other value here"));
21746	21736	}
21747	21737	bigint_incr(&field_index);
21748	21738	}
...	...	@@ -21828,7 +21818,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21828	21818	Buf *err_name = &ira->codegen->errors_by_index.at(start_index)->name;
21829	21819	ErrorMsg *msg = ir_add_error(ira, &start_value->base,
21830	21820	buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&switch_type->name), buf_ptr(err_name)));
21831		add_error_note(ira->codegen, msg, prev_node, buf_sprintf("other value is here"));
	21821	add_error_note(ira->codegen, msg, prev_node, buf_sprintf("other value here"));
21832	21822	}
21833	21823	field_prev_uses[start_index] = start_value->base.source_node;
21834	21824	}
...	...	@@ -21890,7 +21880,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21890	21880	start_value->base.source_node);
21891	21881	if (prev_node != nullptr) {
21892	21882	ErrorMsg *msg = ir_add_error(ira, &start_value->base, buf_sprintf("duplicate switch value"));
21893		add_error_note(ira->codegen, msg, prev_node, buf_sprintf("previous value is here"));
	21883	add_error_note(ira->codegen, msg, prev_node, buf_sprintf("previous value here"));
21894	21884	return ira->codegen->invalid_inst_gen;
21895	21885	}
21896	21886	}
...	...	@@ -21975,7 +21965,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21975	21965	auto entry = prevs.put_unique(const_expr_val->data.x_type, value);
21976	21966	if(entry != nullptr) {
21977	21967	ErrorMsg *msg = ir_add_error(ira, &value->base, buf_sprintf("duplicate switch value"));
21978		add_error_note(ira->codegen, msg, entry->value->base.source_node, buf_sprintf("previous value is here"));
	21968	add_error_note(ira->codegen, msg, entry->value->base.source_node, buf_sprintf("previous value here"));
21979	21969	prevs.deinit();
21980	21970	return ira->codegen->invalid_inst_gen;
21981	21971	}

src/stage1/ir_print.cpp-2

...	...	@@ -577,8 +577,6 @@ static void ir_print_prefix_src(IrPrintSrc irp, IrInstSrc instruction, bool tr
577	577	const char *type_name;
578	578	if (instruction->id == IrInstSrcIdConst) {
579	579	type_name = buf_ptr(&reinterpret_cast<IrInstSrcConst *>(instruction)->value->type->name);
580		} else if (instruction->is_noreturn) {
581		type_name = "noreturn";
582	580	} else {
583	581	type_name = "(unknown)";
584	582	}

src/target.zig+67

...	...	@@ -170,6 +170,73 @@ pub fn hasValgrindSupport(target: std.Target) bool {
170	170	}
171	171	}
172	172
	173	/// The set of targets that LLVM has non-experimental support for.
	174	/// Used to select between LLVM backend and self-hosted backend when compiling in
	175	/// release modes.
	176	pub fn hasLlvmSupport(target: std.Target) bool {
	177	return switch (target.cpu.arch) {
	178	.arm,
	179	.armeb,
	180	.aarch64,
	181	.aarch64_be,
	182	.aarch64_32,
	183	.arc,
	184	.avr,
	185	.bpfel,
	186	.bpfeb,
	187	.csky,
	188	.hexagon,
	189	.mips,
	190	.mipsel,
	191	.mips64,
	192	.mips64el,
	193	.msp430,
	194	.powerpc,
	195	.powerpcle,
	196	.powerpc64,
	197	.powerpc64le,
	198	.r600,
	199	.amdgcn,
	200	.riscv32,
	201	.riscv64,
	202	.sparc,
	203	.sparcv9,
	204	.sparcel,
	205	.s390x,
	206	.tce,
	207	.tcele,
	208	.thumb,
	209	.thumbeb,
	210	.i386,
	211	.x86_64,
	212	.xcore,
	213	.nvptx,
	214	.nvptx64,
	215	.le32,
	216	.le64,
	217	.amdil,
	218	.amdil64,
	219	.hsail,
	220	.hsail64,
	221	.spir,
	222	.spir64,
	223	.kalimba,
	224	.shave,
	225	.lanai,
	226	.wasm32,
	227	.wasm64,
	228	.renderscript32,
	229	.renderscript64,
	230	.ve,
	231	=> true,
	232
	233	.spu_2,
	234	.spirv32,
	235	.spirv64,
	236	=> false,
	237	};
	238	}
	239
173	240	pub fn supportsStackProbing(target: std.Target) bool {
174	241	return target.os.tag != .windows and target.os.tag != .uefi and
175	242	(target.cpu.arch == .i386 or target.cpu.arch == .x86_64);

src/test.zig+328-74

...	...	@@ -10,18 +10,25 @@ const enable_wine: bool = build_options.enable_wine;
10	10	const enable_wasmtime: bool = build_options.enable_wasmtime;
11	11	const enable_darling: bool = build_options.enable_darling;
12	12	const glibc_multi_install_dir: ?[]const u8 = build_options.glibc_multi_install_dir;
	13	const skip_compile_errors = build_options.skip_compile_errors;
13	14	const ThreadPool = @import("ThreadPool.zig");
14	15	const CrossTarget = std.zig.CrossTarget;
	16	const print = std.debug.print;
	17	const assert = std.debug.assert;
15	18
16	19	const zig_h = link.File.C.zig_h;
17	20
18	21	const hr = "=" ** 80;
19	22
20		test "self-hosted" {
	23	test {
	24	if (build_options.is_stage1) {
	25	@import("stage1.zig").os_init();
	26	}
	27
21	28	var ctx = TestContext.init();
22	29	defer ctx.deinit();
23	30
24		try @import("stage2_tests").addCases(&ctx);
	31	try @import("test_cases").addCases(&ctx);
25	32
26	33	try ctx.run();
27	34	}
...	...	@@ -30,7 +37,11 @@ const ErrorMsg = union(enum) {
30	37	src: struct {
31	38	src_path: []const u8,
32	39	msg: []const u8,
	40	// maxint means match anything
	41	// this is a workaround for stage1 compiler bug I ran into when making it ?u32
33	42	line: u32,
	43	// maxint means match anything
	44	// this is a workaround for stage1 compiler bug I ran into when making it ?u32
34	45	column: u32,
35	46	kind: Kind,
36	47	},
...	...	@@ -74,23 +85,32 @@ const ErrorMsg = union(enum) {
74	85	_ = options;
75	86	switch (self) {
76	87	.src => \|src\| {
77		return writer.print("{s}:{d}:{d}: {s}: {s}", .{
78		src.src_path,
79		src.line + 1,
80		src.column + 1,
81		@tagName(src.kind),
82		src.msg,
83		});
	88	if (!std.mem.eql(u8, src.src_path, "?") or
	89	src.line != std.math.maxInt(u32) or
	90	src.column != std.math.maxInt(u32))
	91	{
	92	try writer.print("{s}:", .{src.src_path});
	93	if (src.line != std.math.maxInt(u32)) {
	94	try writer.print("{d}:", .{src.line + 1});
	95	} else {
	96	try writer.writeAll("?:");
	97	}
	98	if (src.column != std.math.maxInt(u32)) {
	99	try writer.print("{d}: ", .{src.column + 1});
	100	} else {
	101	try writer.writeAll("?: ");
	102	}
	103	}
	104	return writer.print("{s}: {s}", .{ @tagName(src.kind), src.msg });
84	105	},
85	106	.plain => \|plain\| {
86		return writer.print("{s}: {s}", .{ plain.msg, @tagName(plain.kind) });
	107	return writer.print("{s}: {s}", .{ @tagName(plain.kind), plain.msg });
87	108	},
88	109	}
89	110	}
90	111	};
91	112
92	113	pub const TestContext = struct {
93		/// TODO: find a way to treat cases as individual tests (shouldn't show "1 test passed" if there are 200 cases)
94	114	cases: std.ArrayList(Case),
95	115
96	116	pub const Update = struct {
...	...	@@ -127,6 +147,12 @@ pub const TestContext = struct {
127	147	path: []const u8,
128	148	};
129	149
	150	pub const Backend = enum {
	151	stage1,
	152	stage2,
	153	llvm,
	154	};
	155
130	156	/// A `Case` consists of a list of `Update`. The same `Compilation` is used for each
131	157	/// update, so each update's source is treated as a single file being
132	158	/// updated by the test harness and incrementally compiled.
...	...	@@ -140,13 +166,20 @@ pub const TestContext = struct {
140	166	/// In order to be able to run e.g. Execution updates, this must be set
141	167	/// to Executable.
142	168	output_mode: std.builtin.OutputMode,
	169	optimize_mode: std.builtin.Mode = .Debug,
143	170	updates: std.ArrayList(Update),
144	171	object_format: ?std.Target.ObjectFormat = null,
145	172	emit_h: bool = false,
146		llvm_backend: bool = false,
	173	is_test: bool = false,
	174	expect_exact: bool = false,
	175	backend: Backend = .stage2,
147	176
148	177	files: std.ArrayList(File),
149	178
	179	pub fn addSourceFile(case: *Case, name: []const u8, src: [:0]const u8) void {
	180	case.files.append(.{ .path = name, .src = src }) catch @panic("out of memory");
	181	}
	182
150	183	/// Adds a subcase in which the module is updated with `src`, and a C
151	184	/// header is generated.
152	185	pub fn addHeader(self: *Case, src: [:0]const u8, result: [:0]const u8) void {
...	...	@@ -201,8 +234,14 @@ pub const TestContext = struct {
201	234	const kind_text = it.next() orelse @panic("missing 'error'/'note'");
202	235	const msg = it.rest()[1..]; // skip over the space at end of "error: "
203	236
204		const line = std.fmt.parseInt(u32, line_text, 10) catch @panic("bad line number");
205		const column = std.fmt.parseInt(u32, col_text, 10) catch @panic("bad column number");
	237	const line: ?u32 = if (std.mem.eql(u8, line_text, "?"))
	238	null
	239	else
	240	std.fmt.parseInt(u32, line_text, 10) catch @panic("bad line number");
	241	const column: ?u32 = if (std.mem.eql(u8, line_text, "?"))
	242	null
	243	else
	244	std.fmt.parseInt(u32, col_text, 10) catch @panic("bad column number");
206	245	const kind: ErrorMsg.Kind = if (std.mem.eql(u8, kind_text, " error"))
207	246	.@"error"
208	247	else if (std.mem.eql(u8, kind_text, " note"))
...	...	@@ -210,16 +249,28 @@ pub const TestContext = struct {
210	249	else
211	250	@panic("expected 'error'/'note'");
212	251
213		if (line == 0 or column == 0) {
214		@panic("line and column must be specified starting at one");
215		}
	252	const line_0based: u32 = if (line) \|n\| blk: {
	253	if (n == 0) {
	254	print("{s}: line must be specified starting at one\n", .{self.name});
	255	return;
	256	}
	257	break :blk n - 1;
	258	} else std.math.maxInt(u32);
	259
	260	const column_0based: u32 = if (column) \|n\| blk: {
	261	if (n == 0) {
	262	print("{s}: line must be specified starting at one\n", .{self.name});
	263	return;
	264	}
	265	break :blk n - 1;
	266	} else std.math.maxInt(u32);
216	267
217	268	array[i] = .{
218	269	.src = .{
219	270	.src_path = src_path,
220	271	.msg = msg,
221		.line = line - 1,
222		.column = column - 1,
	272	.line = line_0based,
	273	.column = column_0based,
223	274	.kind = kind,
224	275	},
225	276	};
...	...	@@ -254,11 +305,6 @@ pub const TestContext = struct {
254	305	return ctx.addExe(name, target);
255	306	}
256	307
257		/// Adds a test case for ZIR input, producing an executable
258		pub fn exeZIR(ctx: TestContext, name: []const u8, target: CrossTarget) Case {
259		return ctx.addExe(name, target, .ZIR);
260		}
261
262	308	pub fn exeFromCompiledC(ctx: TestContext, name: []const u8, target: CrossTarget) Case {
263	309	const prefixed_name = std.fmt.allocPrint(ctx.cases.allocator, "CBE: {s}", .{name}) catch
264	310	@panic("out of memory");
...	...	@@ -282,7 +328,7 @@ pub const TestContext = struct {
282	328	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
283	329	.output_mode = .Exe,
284	330	.files = std.ArrayList(File).init(ctx.cases.allocator),
285		.llvm_backend = true,
	331	.backend = .llvm,
286	332	}) catch @panic("out of memory");
287	333	return &ctx.cases.items[ctx.cases.items.len - 1];
288	334	}
...	...	@@ -302,6 +348,22 @@ pub const TestContext = struct {
302	348	return &ctx.cases.items[ctx.cases.items.len - 1];
303	349	}
304	350
	351	pub fn addTest(
	352	ctx: *TestContext,
	353	name: []const u8,
	354	target: CrossTarget,
	355	) *Case {
	356	ctx.cases.append(Case{
	357	.name = name,
	358	.target = target,
	359	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
	360	.output_mode = .Exe,
	361	.is_test = true,
	362	.files = std.ArrayList(File).init(ctx.cases.allocator),
	363	}) catch @panic("out of memory");
	364	return &ctx.cases.items[ctx.cases.items.len - 1];
	365	}
	366
305	367	/// Adds a test case for Zig input, producing an object file.
306	368	pub fn obj(ctx: TestContext, name: []const u8, target: CrossTarget) Case {
307	369	return ctx.addObj(name, target);
...	...	@@ -333,6 +395,45 @@ pub const TestContext = struct {
333	395	ctx.addC(name, target).addHeader(src, zig_h ++ out);
334	396	}
335	397
	398	pub fn objErrStage1(
	399	ctx: *TestContext,
	400	name: []const u8,
	401	src: [:0]const u8,
	402	expected_errors: []const []const u8,
	403	) void {
	404	if (skip_compile_errors) return;
	405
	406	const case = ctx.addObj(name, .{});
	407	case.backend = .stage1;
	408	case.addError(src, expected_errors);
	409	}
	410
	411	pub fn testErrStage1(
	412	ctx: *TestContext,
	413	name: []const u8,
	414	src: [:0]const u8,
	415	expected_errors: []const []const u8,
	416	) void {
	417	if (skip_compile_errors) return;
	418
	419	const case = ctx.addTest(name, .{});
	420	case.backend = .stage1;
	421	case.addError(src, expected_errors);
	422	}
	423
	424	pub fn exeErrStage1(
	425	ctx: *TestContext,
	426	name: []const u8,
	427	src: [:0]const u8,
	428	expected_errors: []const []const u8,
	429	) void {
	430	if (skip_compile_errors) return;
	431
	432	const case = ctx.addExe(name, .{});
	433	case.backend = .stage1;
	434	case.addError(src, expected_errors);
	435	}
	436
336	437	pub fn addCompareOutput(
337	438	ctx: *TestContext,
338	439	name: []const u8,
...	...	@@ -386,18 +487,6 @@ pub const TestContext = struct {
386	487	ctx.addTransform(name, target, src, result);
387	488	}
388	489
389		/// Adds a test case that cleans up the ZIR source given in `src`, and
390		/// tests the resulting ZIR against `result`
391		pub fn transformZIR(
392		ctx: *TestContext,
393		name: []const u8,
394		target: CrossTarget,
395		src: [:0]const u8,
396		result: [:0]const u8,
397		) void {
398		ctx.addTransform(name, target, .ZIR, src, result);
399		}
400
401	490	pub fn addError(
402	491	ctx: *TestContext,
403	492	name: []const u8,
...	...	@@ -555,7 +644,7 @@ pub const TestContext = struct {
555	644	continue;
556	645
557	646	// Skip tests that require LLVM backend when it is not available
558		if (!build_options.have_llvm and case.llvm_backend)
	647	if (!build_options.have_llvm and case.backend == .llvm)
559	648	continue;
560	649
561	650	var prg_node = root_node.start(case.name, case.updates.items.len);
...	...	@@ -567,7 +656,7 @@ pub const TestContext = struct {
567	656	progress.initial_delay_ns = 0;
568	657	progress.refresh_rate_ns = 0;
569	658
570		self.runOneCase(
	659	runOneCase(
571	660	std.testing.allocator,
572	661	&prg_node,
573	662	case,
...	...	@@ -576,17 +665,16 @@ pub const TestContext = struct {
576	665	global_cache_directory,
577	666	) catch \|err\| {
578	667	fail_count += 1;
579		std.debug.print("test '{s}' failed: {s}\n\n", .{ case.name, @errorName(err) });
	668	print("test '{s}' failed: {s}\n\n", .{ case.name, @errorName(err) });
580	669	};
581	670	}
582	671	if (fail_count != 0) {
583		std.debug.print("{d} tests failed\n", .{fail_count});
	672	print("{d} tests failed\n", .{fail_count});
584	673	return error.TestFailed;
585	674	}
586	675	}
587	676
588	677	fn runOneCase(
589		self: *TestContext,
590	678	allocator: *Allocator,
591	679	root_node: *std.Progress.Node,
592	680	case: Case,
...	...	@@ -594,7 +682,6 @@ pub const TestContext = struct {
594	682	thread_pool: *ThreadPool,
595	683	global_cache_directory: Compilation.Directory,
596	684	) !void {
597		_ = self;
598	685	const target_info = try std.zig.system.NativeTargetInfo.detect(allocator, case.target);
599	686	const target = target_info.target;
600	687
...	...	@@ -607,14 +694,155 @@ pub const TestContext = struct {
607	694
608	695	var cache_dir = try tmp.dir.makeOpenPath("zig-cache", .{});
609	696	defer cache_dir.close();
610		const tmp_dir_path = try std.fs.path.join(arena, &[_][]const u8{ ".", "zig-cache", "tmp", &tmp.sub_path });
	697
	698	const tmp_dir_path = try std.fs.path.join(
	699	arena,
	700	&[_][]const u8{ ".", "zig-cache", "tmp", &tmp.sub_path },
	701	);
	702	const tmp_dir_path_plus_slash = try std.fmt.allocPrint(
	703	arena,
	704	"{s}" ++ std.fs.path.sep_str,
	705	.{tmp_dir_path},
	706	);
	707	const local_cache_path = try std.fs.path.join(
	708	arena,
	709	&[_][]const u8{ tmp_dir_path, "zig-cache" },
	710	);
	711
	712	for (case.files.items) \|file\| {
	713	try tmp.dir.writeFile(file.path, file.src);
	714	}
	715
	716	if (case.backend == .stage1) {
	717	// stage1 backend has limitations:
	718	// * leaks memory
	719	// * calls exit() when a compile error happens
	720	// * cannot handle updates
	721	// because of this we must spawn a child process rather than
	722	// using Compilation directly.
	723	assert(case.updates.items.len == 1);
	724	const update = case.updates.items[0];
	725	try tmp.dir.writeFile(tmp_src_path, update.src);
	726
	727	var zig_args = std.ArrayList([]const u8).init(arena);
	728	try zig_args.append(std.testing.zig_exe_path);
	729
	730	if (case.is_test) {
	731	try zig_args.append("test");
	732	} else switch (case.output_mode) {
	733	.Obj => try zig_args.append("build-obj"),
	734	.Exe => try zig_args.append("build-exe"),
	735	.Lib => try zig_args.append("build-lib"),
	736	}
	737
	738	try zig_args.append(try std.fs.path.join(arena, &.{ tmp_dir_path, tmp_src_path }));
	739
	740	try zig_args.append("--name");
	741	try zig_args.append("test");
	742
	743	try zig_args.append("--cache-dir");
	744	try zig_args.append(local_cache_path);
	745
	746	try zig_args.append("--global-cache-dir");
	747	try zig_args.append(global_cache_directory.path orelse ".");
	748
	749	if (!case.target.isNative()) {
	750	try zig_args.append("-target");
	751	try zig_args.append(try target.zigTriple(arena));
	752	}
	753
	754	try zig_args.append("-O");
	755	try zig_args.append(@tagName(case.optimize_mode));
	756
	757	const result = try std.ChildProcess.exec(.{
	758	.allocator = arena,
	759	.argv = zig_args.items,
	760	});
	761	switch (update.case) {
	762	.Error => \|case_error_list\| {
	763	switch (result.term) {
	764	.Exited => \|code\| {
	765	if (code == 0) {
	766	dumpArgs(zig_args.items);
	767	return error.CompilationIncorrectlySucceeded;
	768	}
	769	},
	770	else => {
	771	dumpArgs(zig_args.items);
	772	return error.CompilationCrashed;
	773	},
	774	}
	775	var ok = true;
	776	if (case.expect_exact) {
	777	var err_iter = std.mem.split(result.stderr, "\n");
	778	var i: usize = 0;
	779	ok = while (err_iter.next()) \|line\| : (i += 1) {
	780	if (i >= case_error_list.len) break false;
	781	const expected = try std.mem.replaceOwned(
	782	u8,
	783	arena,
	784	try std.fmt.allocPrint(arena, "{s}", .{case_error_list[i]}),
	785	"${DIR}",
	786	tmp_dir_path_plus_slash,
	787	);
	788
	789	if (std.mem.indexOf(u8, line, expected) == null) break false;
	790	continue;
	791	} else true;
	792
	793	ok = ok and i == case_error_list.len;
	794
	795	if (!ok) {
	796	print("\n======== Expected these compile errors: ========\n", .{});
	797	for (case_error_list) \|msg\| {
	798	const expected = try std.fmt.allocPrint(arena, "{s}", .{msg});
	799	print("{s}\n", .{expected});
	800	}
	801	}
	802	} else {
	803	for (case_error_list) \|msg\| {
	804	const expected = try std.mem.replaceOwned(
	805	u8,
	806	arena,
	807	try std.fmt.allocPrint(arena, "{s}", .{msg}),
	808	"${DIR}",
	809	tmp_dir_path_plus_slash,
	810	);
	811	if (std.mem.indexOf(u8, result.stderr, expected) == null) {
	812	print(
	813	\\
	814	\\=========== Expected compile error: ============
	815	\\{s}
	816	\\
	817	, .{expected});
	818	ok = false;
	819	break;
	820	}
	821	}
	822	}
	823
	824	if (!ok) {
	825	print(
	826	\\================= Full output: =================
	827	\\{s}
	828	\\================================================
	829	\\
	830	, .{result.stderr});
	831	return error.TestFailed;
	832	}
	833	},
	834	.CompareObjectFile => @panic("TODO implement in the test harness"),
	835	.Execution => @panic("TODO implement in the test harness"),
	836	.Header => @panic("TODO implement in the test harness"),
	837	}
	838	return;
	839	}
	840
611	841	const zig_cache_directory: Compilation.Directory = .{
612	842	.handle = cache_dir,
613		.path = try std.fs.path.join(arena, &[_][]const u8{ tmp_dir_path, "zig-cache" }),
	843	.path = local_cache_path,
614	844	};
615	845
616		const tmp_src_path = "test_case.zig";
617
618	846	var root_pkg: Package = .{
619	847	.root_src_directory = .{ .path = tmp_dir_path, .handle = tmp.dir },
620	848	.root_src_path = tmp_src_path,
...	...	@@ -640,6 +868,14 @@ pub const TestContext = struct {
640	868	.directory = emit_directory,
641	869	.basename = "test_case.h",
642	870	} else null;
	871	const use_llvm: ?bool = switch (case.backend) {
	872	.llvm => true,
	873	else => null,
	874	};
	875	const use_stage1: ?bool = switch (case.backend) {
	876	.stage1 => true,
	877	else => null,
	878	};
643	879	const comp = try Compilation.create(allocator, .{
644	880	.local_cache_directory = zig_cache_directory,
645	881	.global_cache_directory = global_cache_directory,
...	...	@@ -651,8 +887,8 @@ pub const TestContext = struct {
651	887	// and linking. This will require a rework to support multi-file
652	888	// tests.
653	889	.output_mode = case.output_mode,
654		// TODO: support testing optimizations
655		.optimize_mode = .Debug,
	890	.is_test = case.is_test,
	891	.optimize_mode = case.optimize_mode,
656	892	.emit_bin = emit_bin,
657	893	.emit_h = emit_h,
658	894	.root_pkg = &root_pkg,
...	...	@@ -661,17 +897,13 @@ pub const TestContext = struct {
661	897	.is_native_os = case.target.isNativeOs(),
662	898	.is_native_abi = case.target.isNativeAbi(),
663	899	.dynamic_linker = target_info.dynamic_linker.get(),
664		.link_libc = case.llvm_backend,
665		.use_llvm = case.llvm_backend,
666		.use_lld = case.llvm_backend,
	900	.link_libc = case.backend == .llvm,
	901	.use_llvm = use_llvm,
	902	.use_stage1 = use_stage1,
667	903	.self_exe_path = std.testing.zig_exe_path,
668	904	});
669	905	defer comp.destroy();
670	906
671		for (case.files.items) \|file\| {
672		try tmp.dir.writeFile(file.path, file.src);
673		}
674
675	907	for (case.updates.items) \|update, update_index\| {
676	908	var update_node = root_node.start("update", 3);
677	909	update_node.activate();
...	...	@@ -692,19 +924,19 @@ pub const TestContext = struct {
692	924	var all_errors = try comp.getAllErrorsAlloc();
693	925	defer all_errors.deinit(allocator);
694	926	if (all_errors.list.len != 0) {
695		std.debug.print(
	927	print(
696	928	"\nCase '{s}': unexpected errors at update_index={d}:\n{s}\n",
697	929	.{ case.name, update_index, hr },
698	930	);
699	931	for (all_errors.list) \|err_msg\| {
700	932	switch (err_msg) {
701	933	.src => \|src\| {
702		std.debug.print("{s}:{d}:{d}: error: {s}\n{s}\n", .{
	934	print("{s}:{d}:{d}: error: {s}\n{s}\n", .{
703	935	src.src_path, src.line + 1, src.column + 1, src.msg, hr,
704	936	});
705	937	},
706	938	.plain => \|plain\| {
707		std.debug.print("error: {s}\n{s}\n", .{ plain.msg, hr });
	939	print("error: {s}\n{s}\n", .{ plain.msg, hr });
708	940	},
709	941	}
710	942	}
...	...	@@ -757,10 +989,20 @@ pub const TestContext = struct {
757	989	const src_path_ok = case_msg.src.src_path.len == 0 or
758	990	std.mem.eql(u8, case_msg.src.src_path, actual_msg.src_path);
759	991
	992	const expected_msg = try std.mem.replaceOwned(
	993	u8,
	994	arena,
	995	case_msg.src.msg,
	996	"${DIR}",
	997	tmp_dir_path_plus_slash,
	998	);
	999
760	1000	if (src_path_ok and
761		actual_msg.line == case_msg.src.line and
762		actual_msg.column == case_msg.src.column and
763		std.mem.eql(u8, case_msg.src.msg, actual_msg.msg) and
	1001	(case_msg.src.line == std.math.maxInt(u32) or
	1002	actual_msg.line == case_msg.src.line) and
	1003	(case_msg.src.column == std.math.maxInt(u32) or
	1004	actual_msg.column == case_msg.src.column) and
	1005	std.mem.eql(u8, expected_msg, actual_msg.msg) and
764	1006	case_msg.src.kind == .@"error")
765	1007	{
766	1008	handled_errors[i] = true;
...	...	@@ -779,7 +1021,7 @@ pub const TestContext = struct {
779	1021	},
780	1022	}
781	1023	} else {
782		std.debug.print(
	1024	print(
783	1025	"\nUnexpected error:\n{s}\n{}\n{s}",
784	1026	.{ hr, ErrorMsg.init(actual_error, .@"error"), hr },
785	1027	);
...	...	@@ -796,9 +1038,19 @@ pub const TestContext = struct {
796	1038	}
797	1039	if (ex_tag != .src) continue;
798	1040
799		if (actual_msg.line == case_msg.src.line and
800		actual_msg.column == case_msg.src.column and
801		std.mem.eql(u8, case_msg.src.msg, actual_msg.msg) and
	1041	const expected_msg = try std.mem.replaceOwned(
	1042	u8,
	1043	arena,
	1044	case_msg.src.msg,
	1045	"${DIR}",
	1046	tmp_dir_path_plus_slash,
	1047	);
	1048
	1049	if ((case_msg.src.line == std.math.maxInt(u32) or
	1050	actual_msg.line == case_msg.src.line) and
	1051	(case_msg.src.column == std.math.maxInt(u32) or
	1052	actual_msg.column == case_msg.src.column) and
	1053	std.mem.eql(u8, expected_msg, actual_msg.msg) and
802	1054	case_msg.src.kind == .note)
803	1055	{
804	1056	handled_errors[i] = true;
...	...	@@ -817,7 +1069,7 @@ pub const TestContext = struct {
817	1069	},
818	1070	}
819	1071	} else {
820		std.debug.print(
	1072	print(
821	1073	"\nUnexpected note:\n{s}\n{}\n{s}",
822	1074	.{ hr, ErrorMsg.init(note.*, .note), hr },
823	1075	);
...	...	@@ -827,7 +1079,7 @@ pub const TestContext = struct {
827	1079
828	1080	for (handled_errors) \|handled, i\| {
829	1081	if (!handled) {
830		std.debug.print(
	1082	print(
831	1083	"\nExpected error not found:\n{s}\n{}\n{s}",
832	1084	.{ hr, case_error_list[i], hr },
833	1085	);
...	...	@@ -836,7 +1088,7 @@ pub const TestContext = struct {
836	1088	}
837	1089
838	1090	if (any_failed) {
839		std.debug.print("\nupdate_index={d} ", .{update_index});
	1091	print("\nupdate_index={d} ", .{update_index});
840	1092	return error.WrongCompileErrors;
841	1093	}
842	1094	},
...	...	@@ -932,7 +1184,7 @@ pub const TestContext = struct {
932	1184	.cwd_dir = tmp.dir,
933	1185	.cwd = tmp_dir_path,
934	1186	}) catch \|err\| {
935		std.debug.print("\nupdate_index={d} The following command failed with {s}:\n", .{
	1187	print("\nupdate_index={d} The following command failed with {s}:\n", .{
936	1188	update_index, @errorName(err),
937	1189	});
938	1190	dumpArgs(argv.items);
...	...	@@ -947,7 +1199,7 @@ pub const TestContext = struct {
947	1199	switch (exec_result.term) {
948	1200	.Exited => \|code\| {
949	1201	if (code != 0) {
950		std.debug.print("\n{s}\n{s}: execution exited with code {d}:\n", .{
	1202	print("\n{s}\n{s}: execution exited with code {d}:\n", .{
951	1203	exec_result.stderr, case.name, code,
952	1204	});
953	1205	dumpArgs(argv.items);
...	...	@@ -955,7 +1207,7 @@ pub const TestContext = struct {
955	1207	}
956	1208	},
957	1209	else => {
958		std.debug.print("\n{s}\n{s}: execution crashed:\n", .{
	1210	print("\n{s}\n{s}: execution crashed:\n", .{
959	1211	exec_result.stderr, case.name,
960	1212	});
961	1213	dumpArgs(argv.items);
...	...	@@ -974,7 +1226,9 @@ pub const TestContext = struct {
974	1226
975	1227	fn dumpArgs(argv: []const []const u8) void {
976	1228	for (argv) \|arg\| {
977		std.debug.print("{s} ", .{arg});
	1229	print("{s} ", .{arg});
978	1230	}
979		std.debug.print("\n", .{});
	1231	print("\n", .{});
980	1232	}
	1233
	1234	const tmp_src_path = "tmp.zig";

src/translate_c/ast.zig+1-1

...	...	@@ -754,7 +754,7 @@ pub fn render(gpa: *Allocator, nodes: []const Node) !std.zig.ast.Tree {
754	754	});
755	755
756	756	return std.zig.ast.Tree{
757		.source = ctx.buf.toOwnedSlice(),
	757	.source = try ctx.buf.toOwnedSliceSentinel(0),
758	758	.tokens = ctx.tokens.toOwnedSlice(),
759	759	.nodes = ctx.nodes.toOwnedSlice(),
760	760	.extra_data = ctx.extra_data.toOwnedSlice(gpa),

test/cases.zig created+1627

...	...	@@ -0,0 +1,1627 @@
	1	const std = @import("std");
	2	const TestContext = @import("../src/test.zig").TestContext;
	3
	4	// Self-hosted has differing levels of support for various architectures. For now we pass explicit
	5	// target parameters to each test case. At some point we will take this to the next level and have
	6	// a set of targets that all test cases run on unless specifically overridden. For now, each test
	7	// case applies to only the specified target.
	8
	9	const linux_x64 = std.zig.CrossTarget{
	10	.cpu_arch = .x86_64,
	11	.os_tag = .linux,
	12	};
	13
	14	pub fn addCases(ctx: *TestContext) !void {
	15	try @import("compile_errors.zig").addCases(ctx);
	16	try @import("stage2/cbe.zig").addCases(ctx);
	17	try @import("stage2/arm.zig").addCases(ctx);
	18	try @import("stage2/aarch64.zig").addCases(ctx);
	19	try @import("stage2/llvm.zig").addCases(ctx);
	20	try @import("stage2/wasm.zig").addCases(ctx);
	21	try @import("stage2/darwin.zig").addCases(ctx);
	22	try @import("stage2/riscv64.zig").addCases(ctx);
	23
	24	{
	25	var case = ctx.exe("hello world with updates", linux_x64);
	26
	27	case.addError("", &[_][]const u8{
	28	":93:9: error: struct 'tmp.tmp' has no member named 'main'",
	29	});
	30
	31	// Incorrect return type
	32	case.addError(
	33	\\pub export fn _start() noreturn {
	34	\\}
	35	, &[_][]const u8{":2:1: error: expected noreturn, found void"});
	36
	37	// Regular old hello world
	38	case.addCompareOutput(
	39	\\pub export fn _start() noreturn {
	40	\\ print();
	41	\\
	42	\\ exit();
	43	\\}
	44	\\
	45	\\fn print() void {
	46	\\ asm volatile ("syscall"
	47	\\ :
	48	\\ : [number] "{rax}" (1),
	49	\\ [arg1] "{rdi}" (1),
	50	\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
	51	\\ [arg3] "{rdx}" (14)
	52	\\ : "rcx", "r11", "memory"
	53	\\ );
	54	\\ return;
	55	\\}
	56	\\
	57	\\fn exit() noreturn {
	58	\\ asm volatile ("syscall"
	59	\\ :
	60	\\ : [number] "{rax}" (231),
	61	\\ [arg1] "{rdi}" (0)
	62	\\ : "rcx", "r11", "memory"
	63	\\ );
	64	\\ unreachable;
	65	\\}
	66	,
	67	"Hello, World!\n",
	68	);
	69
	70	// Convert to pub fn main
	71	case.addCompareOutput(
	72	\\pub fn main() void {
	73	\\ print();
	74	\\}
	75	\\
	76	\\fn print() void {
	77	\\ asm volatile ("syscall"
	78	\\ :
	79	\\ : [number] "{rax}" (1),
	80	\\ [arg1] "{rdi}" (1),
	81	\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
	82	\\ [arg3] "{rdx}" (14)
	83	\\ : "rcx", "r11", "memory"
	84	\\ );
	85	\\ return;
	86	\\}
	87	,
	88	"Hello, World!\n",
	89	);
	90
	91	// Now change the message only
	92	case.addCompareOutput(
	93	\\pub fn main() void {
	94	\\ print();
	95	\\}
	96	\\
	97	\\fn print() void {
	98	\\ asm volatile ("syscall"
	99	\\ :
	100	\\ : [number] "{rax}" (1),
	101	\\ [arg1] "{rdi}" (1),
	102	\\ [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
	103	\\ [arg3] "{rdx}" (104)
	104	\\ : "rcx", "r11", "memory"
	105	\\ );
	106	\\ return;
	107	\\}
	108	,
	109	"What is up? This is a longer message that will force the data to be relocated in virtual address space.\n",
	110	);
	111	// Now we print it twice.
	112	case.addCompareOutput(
	113	\\pub fn main() void {
	114	\\ print();
	115	\\ print();
	116	\\}
	117	\\
	118	\\fn print() void {
	119	\\ asm volatile ("syscall"
	120	\\ :
	121	\\ : [number] "{rax}" (1),
	122	\\ [arg1] "{rdi}" (1),
	123	\\ [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
	124	\\ [arg3] "{rdx}" (104)
	125	\\ : "rcx", "r11", "memory"
	126	\\ );
	127	\\ return;
	128	\\}
	129	,
	130	\\What is up? This is a longer message that will force the data to be relocated in virtual address space.
	131	\\What is up? This is a longer message that will force the data to be relocated in virtual address space.
	132	\\
	133	);
	134	}
	135
	136	{
	137	var case = ctx.exe("adding numbers at comptime", linux_x64);
	138	case.addCompareOutput(
	139	\\pub export fn _start() noreturn {
	140	\\ asm volatile ("syscall"
	141	\\ :
	142	\\ : [number] "{rax}" (1),
	143	\\ [arg1] "{rdi}" (1),
	144	\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
	145	\\ [arg3] "{rdx}" (10 + 4)
	146	\\ : "rcx", "r11", "memory"
	147	\\ );
	148	\\ asm volatile ("syscall"
	149	\\ :
	150	\\ : [number] "{rax}" (@as(usize, 230) + @as(usize, 1)),
	151	\\ [arg1] "{rdi}" (0)
	152	\\ : "rcx", "r11", "memory"
	153	\\ );
	154	\\ unreachable;
	155	\\}
	156	,
	157	"Hello, World!\n",
	158	);
	159	}
	160
	161	{
	162	var case = ctx.exe("adding numbers at runtime and comptime", linux_x64);
	163	case.addCompareOutput(
	164	\\pub export fn _start() noreturn {
	165	\\ add(3, 4);
	166	\\
	167	\\ exit();
	168	\\}
	169	\\
	170	\\fn add(a: u32, b: u32) void {
	171	\\ if (a + b != 7) unreachable;
	172	\\}
	173	\\
	174	\\fn exit() noreturn {
	175	\\ asm volatile ("syscall"
	176	\\ :
	177	\\ : [number] "{rax}" (231),
	178	\\ [arg1] "{rdi}" (0)
	179	\\ : "rcx", "r11", "memory"
	180	\\ );
	181	\\ unreachable;
	182	\\}
	183	,
	184	"",
	185	);
	186	// comptime function call
	187	case.addCompareOutput(
	188	\\pub export fn _start() noreturn {
	189	\\ exit();
	190	\\}
	191	\\
	192	\\fn add(a: u32, b: u32) u32 {
	193	\\ return a + b;
	194	\\}
	195	\\
	196	\\const x = add(3, 4);
	197	\\
	198	\\fn exit() noreturn {
	199	\\ asm volatile ("syscall"
	200	\\ :
	201	\\ : [number] "{rax}" (231),
	202	\\ [arg1] "{rdi}" (x - 7)
	203	\\ : "rcx", "r11", "memory"
	204	\\ );
	205	\\ unreachable;
	206	\\}
	207	,
	208	"",
	209	);
	210	// Inline function call
	211	case.addCompareOutput(
	212	\\pub export fn _start() noreturn {
	213	\\ var x: usize = 3;
	214	\\ const y = add(1, 2, x);
	215	\\ exit(y - 6);
	216	\\}
	217	\\
	218	\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
	219	\\ return a + b + c;
	220	\\}
	221	\\
	222	\\fn exit(code: usize) noreturn {
	223	\\ asm volatile ("syscall"
	224	\\ :
	225	\\ : [number] "{rax}" (231),
	226	\\ [arg1] "{rdi}" (code)
	227	\\ : "rcx", "r11", "memory"
	228	\\ );
	229	\\ unreachable;
	230	\\}
	231	,
	232	"",
	233	);
	234	}
	235
	236	{
	237	var case = ctx.exe("subtracting numbers at runtime", linux_x64);
	238	case.addCompareOutput(
	239	\\pub fn main() void {
	240	\\ sub(7, 4);
	241	\\}
	242	\\
	243	\\fn sub(a: u32, b: u32) void {
	244	\\ if (a - b != 3) unreachable;
	245	\\}
	246	,
	247	"",
	248	);
	249	}
	250	{
	251	var case = ctx.exe("unused vars", linux_x64);
	252	case.addError(
	253	\\pub fn main() void {
	254	\\ const x = 1;
	255	\\}
	256	, &.{":2:11: error: unused local constant"});
	257	}
	258	{
	259	var case = ctx.exe("@TypeOf", linux_x64);
	260	case.addCompareOutput(
	261	\\pub fn main() void {
	262	\\ var x: usize = 0;
	263	\\ _ = x;
	264	\\ const z = @TypeOf(x, @as(u128, 5));
	265	\\ assert(z == u128);
	266	\\}
	267	\\
	268	\\pub fn assert(ok: bool) void {
	269	\\ if (!ok) unreachable; // assertion failure
	270	\\}
	271	,
	272	"",
	273	);
	274	case.addCompareOutput(
	275	\\pub fn main() void {
	276	\\ const z = @TypeOf(true);
	277	\\ assert(z == bool);
	278	\\}
	279	\\
	280	\\pub fn assert(ok: bool) void {
	281	\\ if (!ok) unreachable; // assertion failure
	282	\\}
	283	,
	284	"",
	285	);
	286	case.addError(
	287	\\pub fn main() void {
	288	\\ _ = @TypeOf(true, 1);
	289	\\}
	290	, &[_][]const u8{":2:9: error: incompatible types: 'bool' and 'comptime_int'"});
	291	}
	292
	293	{
	294	var case = ctx.exe("multiplying numbers at runtime and comptime", linux_x64);
	295	case.addCompareOutput(
	296	\\pub export fn _start() noreturn {
	297	\\ mul(3, 4);
	298	\\
	299	\\ exit();
	300	\\}
	301	\\
	302	\\fn mul(a: u32, b: u32) void {
	303	\\ if (a * b != 12) unreachable;
	304	\\}
	305	\\
	306	\\fn exit() noreturn {
	307	\\ asm volatile ("syscall"
	308	\\ :
	309	\\ : [number] "{rax}" (231),
	310	\\ [arg1] "{rdi}" (0)
	311	\\ : "rcx", "r11", "memory"
	312	\\ );
	313	\\ unreachable;
	314	\\}
	315	,
	316	"",
	317	);
	318	// comptime function call
	319	case.addCompareOutput(
	320	\\pub fn _start() noreturn {
	321	\\ exit();
	322	\\}
	323	\\
	324	\\fn mul(a: u32, b: u32) u32 {
	325	\\ return a * b;
	326	\\}
	327	\\
	328	\\const x = mul(3, 4);
	329	\\
	330	\\fn exit() noreturn {
	331	\\ asm volatile ("syscall"
	332	\\ :
	333	\\ : [number] "{rax}" (231),
	334	\\ [arg1] "{rdi}" (x - 12)
	335	\\ : "rcx", "r11", "memory"
	336	\\ );
	337	\\ unreachable;
	338	\\}
	339	,
	340	"",
	341	);
	342	// Inline function call
	343	case.addCompareOutput(
	344	\\pub export fn _start() noreturn {
	345	\\ var x: usize = 5;
	346	\\ const y = mul(2, 3, x);
	347	\\ exit(y - 30);
	348	\\}
	349	\\
	350	\\fn mul(a: usize, b: usize, c: usize) callconv(.Inline) usize {
	351	\\ return a * b * c;
	352	\\}
	353	\\
	354	\\fn exit(code: usize) noreturn {
	355	\\ asm volatile ("syscall"
	356	\\ :
	357	\\ : [number] "{rax}" (231),
	358	\\ [arg1] "{rdi}" (code)
	359	\\ : "rcx", "r11", "memory"
	360	\\ );
	361	\\ unreachable;
	362	\\}
	363	,
	364	"",
	365	);
	366	}
	367
	368	{
	369	var case = ctx.exe("assert function", linux_x64);
	370	case.addCompareOutput(
	371	\\pub fn main() void {
	372	\\ add(3, 4);
	373	\\}
	374	\\
	375	\\fn add(a: u32, b: u32) void {
	376	\\ assert(a + b == 7);
	377	\\}
	378	\\
	379	\\pub fn assert(ok: bool) void {
	380	\\ if (!ok) unreachable; // assertion failure
	381	\\}
	382	\\
	383	\\fn exit() noreturn {
	384	\\ asm volatile ("syscall"
	385	\\ :
	386	\\ : [number] "{rax}" (231),
	387	\\ [arg1] "{rdi}" (0)
	388	\\ : "rcx", "r11", "memory"
	389	\\ );
	390	\\ unreachable;
	391	\\}
	392	,
	393	"",
	394	);
	395
	396	// Tests copying a register. For the `c = a + b`, it has to
	397	// preserve both a and b, because they are both used later.
	398	case.addCompareOutput(
	399	\\pub fn main() void {
	400	\\ add(3, 4);
	401	\\}
	402	\\
	403	\\fn add(a: u32, b: u32) void {
	404	\\ const c = a + b; // 7
	405	\\ const d = a + c; // 10
	406	\\ const e = d + b; // 14
	407	\\ assert(e == 14);
	408	\\}
	409	\\
	410	\\pub fn assert(ok: bool) void {
	411	\\ if (!ok) unreachable; // assertion failure
	412	\\}
	413	,
	414	"",
	415	);
	416
	417	// More stress on the liveness detection.
	418	case.addCompareOutput(
	419	\\pub fn main() void {
	420	\\ add(3, 4);
	421	\\}
	422	\\
	423	\\fn add(a: u32, b: u32) void {
	424	\\ const c = a + b; // 7
	425	\\ const d = a + c; // 10
	426	\\ const e = d + b; // 14
	427	\\ const f = d + e; // 24
	428	\\ const g = e + f; // 38
	429	\\ const h = f + g; // 62
	430	\\ const i = g + h; // 100
	431	\\ assert(i == 100);
	432	\\}
	433	\\
	434	\\pub fn assert(ok: bool) void {
	435	\\ if (!ok) unreachable; // assertion failure
	436	\\}
	437	,
	438	"",
	439	);
	440
	441	// Requires a second move. The register allocator should figure out to re-use rax.
	442	case.addCompareOutput(
	443	\\pub fn main() void {
	444	\\ add(3, 4);
	445	\\}
	446	\\
	447	\\fn add(a: u32, b: u32) void {
	448	\\ const c = a + b; // 7
	449	\\ const d = a + c; // 10
	450	\\ const e = d + b; // 14
	451	\\ const f = d + e; // 24
	452	\\ const g = e + f; // 38
	453	\\ const h = f + g; // 62
	454	\\ const i = g + h; // 100
	455	\\ const j = i + d; // 110
	456	\\ assert(j == 110);
	457	\\}
	458	\\
	459	\\pub fn assert(ok: bool) void {
	460	\\ if (!ok) unreachable; // assertion failure
	461	\\}
	462	,
	463	"",
	464	);
	465
	466	// Now we test integer return values.
	467	case.addCompareOutput(
	468	\\pub fn main() void {
	469	\\ assert(add(3, 4) == 7);
	470	\\ assert(add(20, 10) == 30);
	471	\\}
	472	\\
	473	\\fn add(a: u32, b: u32) u32 {
	474	\\ return a + b;
	475	\\}
	476	\\
	477	\\pub fn assert(ok: bool) void {
	478	\\ if (!ok) unreachable; // assertion failure
	479	\\}
	480	,
	481	"",
	482	);
	483
	484	// Local mutable variables.
	485	case.addCompareOutput(
	486	\\pub fn main() void {
	487	\\ assert(add(3, 4) == 7);
	488	\\ assert(add(20, 10) == 30);
	489	\\}
	490	\\
	491	\\fn add(a: u32, b: u32) u32 {
	492	\\ var x: u32 = undefined;
	493	\\ x = 0;
	494	\\ x += a;
	495	\\ x += b;
	496	\\ return x;
	497	\\}
	498	\\
	499	\\pub fn assert(ok: bool) void {
	500	\\ if (!ok) unreachable; // assertion failure
	501	\\}
	502	,
	503	"",
	504	);
	505
	506	// Optionals
	507	case.addCompareOutput(
	508	\\pub fn main() void {
	509	\\ const a: u32 = 2;
	510	\\ const b: ?u32 = a;
	511	\\ const c = b.?;
	512	\\ if (c != 2) unreachable;
	513	\\}
	514	,
	515	"",
	516	);
	517
	518	// While loops
	519	case.addCompareOutput(
	520	\\pub fn main() void {
	521	\\ var i: u32 = 0;
	522	\\ while (i < 4) : (i += 1) print();
	523	\\ assert(i == 4);
	524	\\}
	525	\\
	526	\\fn print() void {
	527	\\ asm volatile ("syscall"
	528	\\ :
	529	\\ : [number] "{rax}" (1),
	530	\\ [arg1] "{rdi}" (1),
	531	\\ [arg2] "{rsi}" (@ptrToInt("hello\n")),
	532	\\ [arg3] "{rdx}" (6)
	533	\\ : "rcx", "r11", "memory"
	534	\\ );
	535	\\ return;
	536	\\}
	537	\\
	538	\\pub fn assert(ok: bool) void {
	539	\\ if (!ok) unreachable; // assertion failure
	540	\\}
	541	,
	542	"hello\nhello\nhello\nhello\n",
	543	);
	544
	545	// inline while requires the condition to be comptime known.
	546	case.addError(
	547	\\pub fn main() void {
	548	\\ var i: u32 = 0;
	549	\\ inline while (i < 4) : (i += 1) print();
	550	\\ assert(i == 4);
	551	\\}
	552	\\
	553	\\fn print() void {
	554	\\ asm volatile ("syscall"
	555	\\ :
	556	\\ : [number] "{rax}" (1),
	557	\\ [arg1] "{rdi}" (1),
	558	\\ [arg2] "{rsi}" (@ptrToInt("hello\n")),
	559	\\ [arg3] "{rdx}" (6)
	560	\\ : "rcx", "r11", "memory"
	561	\\ );
	562	\\ return;
	563	\\}
	564	\\
	565	\\pub fn assert(ok: bool) void {
	566	\\ if (!ok) unreachable; // assertion failure
	567	\\}
	568	, &[_][]const u8{":3:21: error: unable to resolve comptime value"});
	569
	570	// Labeled blocks (no conditional branch)
	571	case.addCompareOutput(
	572	\\pub fn main() void {
	573	\\ assert(add(3, 4) == 20);
	574	\\}
	575	\\
	576	\\fn add(a: u32, b: u32) u32 {
	577	\\ const x: u32 = blk: {
	578	\\ const c = a + b; // 7
	579	\\ const d = a + c; // 10
	580	\\ const e = d + b; // 14
	581	\\ break :blk e;
	582	\\ };
	583	\\ const y = x + a; // 17
	584	\\ const z = y + a; // 20
	585	\\ return z;
	586	\\}
	587	\\
	588	\\pub fn assert(ok: bool) void {
	589	\\ if (!ok) unreachable; // assertion failure
	590	\\}
	591	,
	592	"",
	593	);
	594
	595	// This catches a possible bug in the logic for re-using dying operands.
	596	case.addCompareOutput(
	597	\\pub fn main() void {
	598	\\ assert(add(3, 4) == 116);
	599	\\}
	600	\\
	601	\\fn add(a: u32, b: u32) u32 {
	602	\\ const x: u32 = blk: {
	603	\\ const c = a + b; // 7
	604	\\ const d = a + c; // 10
	605	\\ const e = d + b; // 14
	606	\\ const f = d + e; // 24
	607	\\ const g = e + f; // 38
	608	\\ const h = f + g; // 62
	609	\\ const i = g + h; // 100
	610	\\ const j = i + d; // 110
	611	\\ break :blk j;
	612	\\ };
	613	\\ const y = x + a; // 113
	614	\\ const z = y + a; // 116
	615	\\ return z;
	616	\\}
	617	\\
	618	\\pub fn assert(ok: bool) void {
	619	\\ if (!ok) unreachable; // assertion failure
	620	\\}
	621	,
	622	"",
	623	);
	624
	625	// Spilling registers to the stack.
	626	case.addCompareOutput(
	627	\\pub fn main() void {
	628	\\ assert(add(3, 4) == 1221);
	629	\\ assert(mul(3, 4) == 21609);
	630	\\}
	631	\\
	632	\\fn add(a: u32, b: u32) u32 {
	633	\\ const x: u32 = blk: {
	634	\\ const c = a + b; // 7
	635	\\ const d = a + c; // 10
	636	\\ const e = d + b; // 14
	637	\\ const f = d + e; // 24
	638	\\ const g = e + f; // 38
	639	\\ const h = f + g; // 62
	640	\\ const i = g + h; // 100
	641	\\ const j = i + d; // 110
	642	\\ const k = i + j; // 210
	643	\\ const l = j + k; // 320
	644	\\ const m = l + c; // 327
	645	\\ const n = m + d; // 337
	646	\\ const o = n + e; // 351
	647	\\ const p = o + f; // 375
	648	\\ const q = p + g; // 413
	649	\\ const r = q + h; // 475
	650	\\ const s = r + i; // 575
	651	\\ const t = s + j; // 685
	652	\\ const u = t + k; // 895
	653	\\ const v = u + l; // 1215
	654	\\ break :blk v;
	655	\\ };
	656	\\ const y = x + a; // 1218
	657	\\ const z = y + a; // 1221
	658	\\ return z;
	659	\\}
	660	\\
	661	\\fn mul(a: u32, b: u32) u32 {
	662	\\ const x: u32 = blk: {
	663	\\ const c = a * a * a * a; // 81
	664	\\ const d = a * a * a * b; // 108
	665	\\ const e = a * a * b * a; // 108
	666	\\ const f = a * a * b * b; // 144
	667	\\ const g = a * b * a * a; // 108
	668	\\ const h = a * b * a * b; // 144
	669	\\ const i = a * b * b * a; // 144
	670	\\ const j = a * b * b * b; // 192
	671	\\ const k = b * a * a * a; // 108
	672	\\ const l = b * a * a * b; // 144
	673	\\ const m = b * a * b * a; // 144
	674	\\ const n = b * a * b * b; // 192
	675	\\ const o = b * b * a * a; // 144
	676	\\ const p = b * b * a * b; // 192
	677	\\ const q = b * b * b * a; // 192
	678	\\ const r = b * b * b * b; // 256
	679	\\ const s = c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r; // 2401
	680	\\ break :blk s;
	681	\\ };
	682	\\ const y = x * a; // 7203
	683	\\ const z = y * a; // 21609
	684	\\ return z;
	685	\\}
	686	\\
	687	\\pub fn assert(ok: bool) void {
	688	\\ if (!ok) unreachable; // assertion failure
	689	\\}
	690	,
	691	"",
	692	);
	693
	694	// Reusing the registers of dead operands playing nicely with conditional branching.
	695	case.addCompareOutput(
	696	\\pub fn main() void {
	697	\\ assert(add(3, 4) == 791);
	698	\\ assert(add(4, 3) == 79);
	699	\\}
	700	\\
	701	\\fn add(a: u32, b: u32) u32 {
	702	\\ const x: u32 = if (a < b) blk: {
	703	\\ const c = a + b; // 7
	704	\\ const d = a + c; // 10
	705	\\ const e = d + b; // 14
	706	\\ const f = d + e; // 24
	707	\\ const g = e + f; // 38
	708	\\ const h = f + g; // 62
	709	\\ const i = g + h; // 100
	710	\\ const j = i + d; // 110
	711	\\ const k = i + j; // 210
	712	\\ const l = k + c; // 217
	713	\\ const m = l + d; // 227
	714	\\ const n = m + e; // 241
	715	\\ const o = n + f; // 265
	716	\\ const p = o + g; // 303
	717	\\ const q = p + h; // 365
	718	\\ const r = q + i; // 465
	719	\\ const s = r + j; // 575
	720	\\ const t = s + k; // 785
	721	\\ break :blk t;
	722	\\ } else blk: {
	723	\\ const t = b + b + a; // 10
	724	\\ const c = a + t; // 14
	725	\\ const d = c + t; // 24
	726	\\ const e = d + t; // 34
	727	\\ const f = e + t; // 44
	728	\\ const g = f + t; // 54
	729	\\ const h = c + g; // 68
	730	\\ break :blk h + b; // 71
	731	\\ };
	732	\\ const y = x + a; // 788, 75
	733	\\ const z = y + a; // 791, 79
	734	\\ return z;
	735	\\}
	736	\\
	737	\\pub fn assert(ok: bool) void {
	738	\\ if (!ok) unreachable; // assertion failure
	739	\\}
	740	,
	741	"",
	742	);
	743
	744	// Character literals and multiline strings.
	745	case.addCompareOutput(
	746	\\pub fn main() void {
	747	\\ const ignore =
	748	\\ \\ cool thx
	749	\\ \\
	750	\\ ;
	751	\\ _ = ignore;
	752	\\ add('ぁ', '\x03');
	753	\\}
	754	\\
	755	\\fn add(a: u32, b: u32) void {
	756	\\ assert(a + b == 12356);
	757	\\}
	758	\\
	759	\\pub fn assert(ok: bool) void {
	760	\\ if (!ok) unreachable; // assertion failure
	761	\\}
	762	,
	763	"",
	764	);
	765
	766	// Global const.
	767	case.addCompareOutput(
	768	\\pub fn main() void {
	769	\\ add(aa, bb);
	770	\\}
	771	\\
	772	\\const aa = 'ぁ';
	773	\\const bb = '\x03';
	774	\\
	775	\\fn add(a: u32, b: u32) void {
	776	\\ assert(a + b == 12356);
	777	\\}
	778	\\
	779	\\pub fn assert(ok: bool) void {
	780	\\ if (!ok) unreachable; // assertion failure
	781	\\}
	782	,
	783	"",
	784	);
	785
	786	// Array access.
	787	case.addCompareOutput(
	788	\\pub fn main() void {
	789	\\ assert("hello"[0] == 'h');
	790	\\}
	791	\\
	792	\\pub fn assert(ok: bool) void {
	793	\\ if (!ok) unreachable; // assertion failure
	794	\\}
	795	,
	796	"",
	797	);
	798
	799	// Array access to a global array.
	800	case.addCompareOutput(
	801	\\const hello = "hello".*;
	802	\\pub fn main() void {
	803	\\ assert(hello[1] == 'e');
	804	\\}
	805	\\
	806	\\pub fn assert(ok: bool) void {
	807	\\ if (!ok) unreachable; // assertion failure
	808	\\}
	809	,
	810	"",
	811	);
	812
	813	// 64bit set stack
	814	case.addCompareOutput(
	815	\\pub fn main() void {
	816	\\ var i: u64 = 0xFFEEDDCCBBAA9988;
	817	\\ assert(i == 0xFFEEDDCCBBAA9988);
	818	\\}
	819	\\
	820	\\pub fn assert(ok: bool) void {
	821	\\ if (!ok) unreachable; // assertion failure
	822	\\}
	823	,
	824	"",
	825	);
	826
	827	// Basic for loop
	828	case.addCompareOutput(
	829	\\pub fn main() void {
	830	\\ for ("hello") \|_\| print();
	831	\\}
	832	\\
	833	\\fn print() void {
	834	\\ asm volatile ("syscall"
	835	\\ :
	836	\\ : [number] "{rax}" (1),
	837	\\ [arg1] "{rdi}" (1),
	838	\\ [arg2] "{rsi}" (@ptrToInt("hello\n")),
	839	\\ [arg3] "{rdx}" (6)
	840	\\ : "rcx", "r11", "memory"
	841	\\ );
	842	\\ return;
	843	\\}
	844	,
	845	"hello\nhello\nhello\nhello\nhello\n",
	846	);
	847	}
	848
	849	{
	850	var case = ctx.exe("basic import", linux_x64);
	851	case.addCompareOutput(
	852	\\pub fn main() void {
	853	\\ @import("print.zig").print();
	854	\\}
	855	,
	856	"Hello, World!\n",
	857	);
	858	try case.files.append(.{
	859	.src =
	860	\\pub fn print() void {
	861	\\ asm volatile ("syscall"
	862	\\ :
	863	\\ : [number] "{rax}" (@as(usize, 1)),
	864	\\ [arg1] "{rdi}" (@as(usize, 1)),
	865	\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
	866	\\ [arg3] "{rdx}" (@as(usize, 14))
	867	\\ : "rcx", "r11", "memory"
	868	\\ );
	869	\\ return;
	870	\\}
	871	,
	872	.path = "print.zig",
	873	});
	874	}
	875	{
	876	var case = ctx.exe("redundant comptime", linux_x64);
	877	case.addError(
	878	\\pub fn main() void {
	879	\\ var a: comptime u32 = 0;
	880	\\}
	881	,
	882	&.{":2:12: error: redundant comptime keyword in already comptime scope"},
	883	);
	884	case.addError(
	885	\\pub fn main() void {
	886	\\ comptime {
	887	\\ var a: u32 = comptime 0;
	888	\\ }
	889	\\}
	890	,
	891	&.{":3:22: error: redundant comptime keyword in already comptime scope"},
	892	);
	893	}
	894	{
	895	var case = ctx.exe("try in comptime in struct in test", linux_x64);
	896	case.addError(
	897	\\test "@unionInit on union w/ tag but no fields" {
	898	\\ const S = struct {
	899	\\ comptime {
	900	\\ try expect(false);
	901	\\ }
	902	\\ };
	903	\\ _ = S;
	904	\\}
	905	,
	906	&.{":4:13: error: invalid 'try' outside function scope"},
	907	);
	908	}
	909	{
	910	var case = ctx.exe("import private", linux_x64);
	911	case.addError(
	912	\\pub fn main() void {
	913	\\ @import("print.zig").print();
	914	\\}
	915	,
	916	&.{
	917	":2:25: error: 'print' is not marked 'pub'",
	918	"print.zig:2:1: note: declared here",
	919	},
	920	);
	921	try case.files.append(.{
	922	.src =
	923	\\// dummy comment to make print be on line 2
	924	\\fn print() void {
	925	\\ asm volatile ("syscall"
	926	\\ :
	927	\\ : [number] "{rax}" (@as(usize, 1)),
	928	\\ [arg1] "{rdi}" (@as(usize, 1)),
	929	\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
	930	\\ [arg3] "{rdx}" (@as(usize, 14))
	931	\\ : "rcx", "r11", "memory"
	932	\\ );
	933	\\ return;
	934	\\}
	935	,
	936	.path = "print.zig",
	937	});
	938	}
	939
	940	ctx.compileError("function redeclaration", linux_x64,
	941	\\// dummy comment
	942	\\fn entry() void {}
	943	\\fn entry() void {}
	944	\\
	945	\\fn foo() void {
	946	\\ var foo = 1234;
	947	\\}
	948	, &[_][]const u8{
	949	":3:1: error: redeclaration of 'entry'",
	950	":2:1: note: other declaration here",
	951	":6:9: error: local shadows declaration of 'foo'",
	952	":5:1: note: declared here",
	953	});
	954
	955	ctx.compileError("returns in try", linux_x64,
	956	\\pub fn main() !void {
	957	\\ try a();
	958	\\ try b();
	959	\\}
	960	\\
	961	\\pub fn a() !void {
	962	\\ defer try b();
	963	\\}
	964	\\pub fn b() !void {
	965	\\ defer return a();
	966	\\}
	967	, &[_][]const u8{
	968	":7:8: error: 'try' not allowed inside defer expression",
	969	":10:8: error: cannot return from defer expression",
	970	});
	971
	972	ctx.compileError("ambiguous references", linux_x64,
	973	\\const T = struct {
	974	\\ const T = struct {
	975	\\ fn f() void {
	976	\\ _ = T;
	977	\\ }
	978	\\ };
	979	\\};
	980	, &.{
	981	":4:17: error: ambiguous reference",
	982	":1:1: note: declared here",
	983	":2:5: note: also declared here",
	984	});
	985
	986	ctx.compileError("inner func accessing outer var", linux_x64,
	987	\\pub fn f() void {
	988	\\ var bar: bool = true;
	989	\\ const S = struct {
	990	\\ fn baz() bool {
	991	\\ return bar;
	992	\\ }
	993	\\ };
	994	\\ _ = S;
	995	\\}
	996	, &.{
	997	":5:20: error: 'bar' not accessible from inner function",
	998	":2:9: note: declared here",
	999	});
	1000
	1001	ctx.compileError("global variable redeclaration", linux_x64,
	1002	\\// dummy comment
	1003	\\var foo = false;
	1004	\\var foo = true;
	1005	, &[_][]const u8{
	1006	":3:1: error: redeclaration of 'foo'",
	1007	":2:1: note: other declaration here",
	1008	});
	1009
	1010	ctx.compileError("compileError", linux_x64,
	1011	\\export fn foo() void {
	1012	\\ @compileError("this is an error");
	1013	\\}
	1014	, &[_][]const u8{":2:3: error: this is an error"});
	1015
	1016	{
	1017	var case = ctx.exe("intToPtr", linux_x64);
	1018	case.addError(
	1019	\\pub fn main() void {
	1020	\\ _ = @intToPtr(*u8, 0);
	1021	\\}
	1022	, &[_][]const u8{
	1023	":2:24: error: pointer type '*u8' does not allow address zero",
	1024	});
	1025	case.addError(
	1026	\\pub fn main() void {
	1027	\\ _ = @intToPtr(*u32, 2);
	1028	\\}
	1029	, &[_][]const u8{
	1030	":2:25: error: pointer type '*u32' requires aligned address",
	1031	});
	1032	}
	1033
	1034	{
	1035	var case = ctx.obj("variable shadowing", linux_x64);
	1036	case.addError(
	1037	\\pub fn main() void {
	1038	\\ var i: u32 = 10;
	1039	\\ var i: u32 = 10;
	1040	\\}
	1041	, &[_][]const u8{
	1042	":3:9: error: redeclaration of local variable 'i'",
	1043	":2:9: note: previous declaration here",
	1044	});
	1045	case.addError(
	1046	\\var testing: i64 = 10;
	1047	\\pub fn main() void {
	1048	\\ var testing: i64 = 20;
	1049	\\}
	1050	, &[_][]const u8{
	1051	":3:9: error: local shadows declaration of 'testing'",
	1052	":1:1: note: declared here",
	1053	});
	1054	case.addError(
	1055	\\fn a() type {
	1056	\\ return struct {
	1057	\\ pub fn b() void {
	1058	\\ const c = 6;
	1059	\\ const c = 69;
	1060	\\ }
	1061	\\ };
	1062	\\}
	1063	, &[_][]const u8{
	1064	":5:19: error: redeclaration of local constant 'c'",
	1065	":4:19: note: previous declaration here",
	1066	});
	1067	}
	1068
	1069	{
	1070	// TODO make the test harness support checking the compile log output too
	1071	var case = ctx.obj("@compileLog", linux_x64);
	1072	// The other compile error prevents emission of a "found compile log" statement.
	1073	case.addError(
	1074	\\export fn _start() noreturn {
	1075	\\ const b = true;
	1076	\\ var f: u32 = 1;
	1077	\\ @compileLog(b, 20, f, x);
	1078	\\ @compileLog(1000);
	1079	\\ var bruh: usize = true;
	1080	\\ _ = bruh;
	1081	\\ unreachable;
	1082	\\}
	1083	\\export fn other() void {
	1084	\\ @compileLog(1234);
	1085	\\}
	1086	\\fn x() void {}
	1087	, &[_][]const u8{
	1088	":6:23: error: expected usize, found bool",
	1089	});
	1090
	1091	// Now only compile log statements remain. One per Decl.
	1092	case.addError(
	1093	\\export fn _start() noreturn {
	1094	\\ const b = true;
	1095	\\ var f: u32 = 1;
	1096	\\ @compileLog(b, 20, f, x);
	1097	\\ @compileLog(1000);
	1098	\\ unreachable;
	1099	\\}
	1100	\\export fn other() void {
	1101	\\ @compileLog(1234);
	1102	\\}
	1103	\\fn x() void {}
	1104	, &[_][]const u8{
	1105	":9:5: error: found compile log statement",
	1106	":4:5: note: also here",
	1107	});
	1108	}
	1109
	1110	{
	1111	var case = ctx.obj("extern variable has no type", linux_x64);
	1112	case.addError(
	1113	\\comptime {
	1114	\\ _ = foo;
	1115	\\}
	1116	\\extern var foo: i32;
	1117	, &[_][]const u8{":2:9: error: unable to resolve comptime value"});
	1118	case.addError(
	1119	\\export fn entry() void {
	1120	\\ _ = foo;
	1121	\\}
	1122	\\extern var foo;
	1123	, &[_][]const u8{":4:8: error: unable to infer variable type"});
	1124	}
	1125
	1126	{
	1127	var case = ctx.exe("break/continue", linux_x64);
	1128
	1129	// Break out of loop
	1130	case.addCompareOutput(
	1131	\\pub fn main() void {
	1132	\\ while (true) {
	1133	\\ break;
	1134	\\ }
	1135	\\}
	1136	,
	1137	"",
	1138	);
	1139	case.addCompareOutput(
	1140	\\pub fn main() void {
	1141	\\ foo: while (true) {
	1142	\\ break :foo;
	1143	\\ }
	1144	\\}
	1145	,
	1146	"",
	1147	);
	1148
	1149	// Continue in loop
	1150	case.addCompareOutput(
	1151	\\pub export fn _start() noreturn {
	1152	\\ var i: u64 = 0;
	1153	\\ while (true) : (i+=1) {
	1154	\\ if (i == 4) exit();
	1155	\\ continue;
	1156	\\ }
	1157	\\}
	1158	\\
	1159	\\fn exit() noreturn {
	1160	\\ asm volatile ("syscall"
	1161	\\ :
	1162	\\ : [number] "{rax}" (231),
	1163	\\ [arg1] "{rdi}" (0)
	1164	\\ : "rcx", "r11", "memory"
	1165	\\ );
	1166	\\ unreachable;
	1167	\\}
	1168	,
	1169	"",
	1170	);
	1171	case.addCompareOutput(
	1172	\\pub export fn _start() noreturn {
	1173	\\ var i: u64 = 0;
	1174	\\ foo: while (true) : (i+=1) {
	1175	\\ if (i == 4) exit();
	1176	\\ continue :foo;
	1177	\\ }
	1178	\\}
	1179	\\
	1180	\\fn exit() noreturn {
	1181	\\ asm volatile ("syscall"
	1182	\\ :
	1183	\\ : [number] "{rax}" (231),
	1184	\\ [arg1] "{rdi}" (0)
	1185	\\ : "rcx", "r11", "memory"
	1186	\\ );
	1187	\\ unreachable;
	1188	\\}
	1189	,
	1190	"",
	1191	);
	1192	}
	1193
	1194	{
	1195	var case = ctx.exe("unused labels", linux_x64);
	1196	case.addError(
	1197	\\comptime {
	1198	\\ foo: {}
	1199	\\}
	1200	, &[_][]const u8{":2:5: error: unused block label"});
	1201	case.addError(
	1202	\\comptime {
	1203	\\ foo: while (true) {}
	1204	\\}
	1205	, &[_][]const u8{":2:5: error: unused while loop label"});
	1206	case.addError(
	1207	\\comptime {
	1208	\\ foo: for ("foo") \|_\| {}
	1209	\\}
	1210	, &[_][]const u8{":2:5: error: unused for loop label"});
	1211	case.addError(
	1212	\\comptime {
	1213	\\ blk: {blk: {}}
	1214	\\}
	1215	, &[_][]const u8{
	1216	":2:11: error: redefinition of label 'blk'",
	1217	":2:5: note: previous definition here",
	1218	});
	1219	}
	1220
	1221	{
	1222	var case = ctx.exe("bad inferred variable type", linux_x64);
	1223	case.addError(
	1224	\\pub fn main() void {
	1225	\\ var x = null;
	1226	\\ _ = x;
	1227	\\}
	1228	, &[_][]const u8{
	1229	":2:9: error: variable of type '@Type(.Null)' must be const or comptime",
	1230	});
	1231	}
	1232
	1233	{
	1234	var case = ctx.exe("compile error in inline fn call fixed", linux_x64);
	1235	case.addError(
	1236	\\pub export fn _start() noreturn {
	1237	\\ var x: usize = 3;
	1238	\\ const y = add(10, 2, x);
	1239	\\ exit(y - 6);
	1240	\\}
	1241	\\
	1242	\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
	1243	\\ if (a == 10) @compileError("bad");
	1244	\\ return a + b + c;
	1245	\\}
	1246	\\
	1247	\\fn exit(code: usize) noreturn {
	1248	\\ asm volatile ("syscall"
	1249	\\ :
	1250	\\ : [number] "{rax}" (231),
	1251	\\ [arg1] "{rdi}" (code)
	1252	\\ : "rcx", "r11", "memory"
	1253	\\ );
	1254	\\ unreachable;
	1255	\\}
	1256	, &[_][]const u8{":8:18: error: bad"});
	1257
	1258	case.addCompareOutput(
	1259	\\pub export fn _start() noreturn {
	1260	\\ var x: usize = 3;
	1261	\\ const y = add(1, 2, x);
	1262	\\ exit(y - 6);
	1263	\\}
	1264	\\
	1265	\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
	1266	\\ if (a == 10) @compileError("bad");
	1267	\\ return a + b + c;
	1268	\\}
	1269	\\
	1270	\\fn exit(code: usize) noreturn {
	1271	\\ asm volatile ("syscall"
	1272	\\ :
	1273	\\ : [number] "{rax}" (231),
	1274	\\ [arg1] "{rdi}" (code)
	1275	\\ : "rcx", "r11", "memory"
	1276	\\ );
	1277	\\ unreachable;
	1278	\\}
	1279	,
	1280	"",
	1281	);
	1282	}
	1283	{
	1284	var case = ctx.exe("recursive inline function", linux_x64);
	1285	case.addCompareOutput(
	1286	\\pub export fn _start() noreturn {
	1287	\\ const y = fibonacci(7);
	1288	\\ exit(y - 21);
	1289	\\}
	1290	\\
	1291	\\fn fibonacci(n: usize) callconv(.Inline) usize {
	1292	\\ if (n <= 2) return n;
	1293	\\ return fibonacci(n - 2) + fibonacci(n - 1);
	1294	\\}
	1295	\\
	1296	\\fn exit(code: usize) noreturn {
	1297	\\ asm volatile ("syscall"
	1298	\\ :
	1299	\\ : [number] "{rax}" (231),
	1300	\\ [arg1] "{rdi}" (code)
	1301	\\ : "rcx", "r11", "memory"
	1302	\\ );
	1303	\\ unreachable;
	1304	\\}
	1305	,
	1306	"",
	1307	);
	1308	// This additionally tests that the compile error reports the correct source location.
	1309	// Without storing source locations relative to the owner decl, the compile error
	1310	// here would be off by 2 bytes (from the "7" -> "999").
	1311	case.addError(
	1312	\\pub export fn _start() noreturn {
	1313	\\ const y = fibonacci(999);
	1314	\\ exit(y - 21);
	1315	\\}
	1316	\\
	1317	\\fn fibonacci(n: usize) callconv(.Inline) usize {
	1318	\\ if (n <= 2) return n;
	1319	\\ return fibonacci(n - 2) + fibonacci(n - 1);
	1320	\\}
	1321	\\
	1322	\\fn exit(code: usize) noreturn {
	1323	\\ asm volatile ("syscall"
	1324	\\ :
	1325	\\ : [number] "{rax}" (231),
	1326	\\ [arg1] "{rdi}" (code)
	1327	\\ : "rcx", "r11", "memory"
	1328	\\ );
	1329	\\ unreachable;
	1330	\\}
	1331	, &[_][]const u8{":8:21: error: evaluation exceeded 1000 backwards branches"});
	1332	}
	1333	{
	1334	var case = ctx.exe("orelse at comptime", linux_x64);
	1335	case.addCompareOutput(
	1336	\\pub fn main() void {
	1337	\\ const i: ?u64 = 0;
	1338	\\ const result = i orelse 5;
	1339	\\ assert(result == 0);
	1340	\\}
	1341	\\fn assert(b: bool) void {
	1342	\\ if (!b) unreachable;
	1343	\\}
	1344	,
	1345	"",
	1346	);
	1347	case.addCompareOutput(
	1348	\\pub fn main() void {
	1349	\\ const i: ?u64 = null;
	1350	\\ const result = i orelse 5;
	1351	\\ assert(result == 5);
	1352	\\}
	1353	\\fn assert(b: bool) void {
	1354	\\ if (!b) unreachable;
	1355	\\}
	1356	,
	1357	"",
	1358	);
	1359	}
	1360
	1361	{
	1362	var case = ctx.exe("only 1 function and it gets updated", linux_x64);
	1363	case.addCompareOutput(
	1364	\\pub export fn _start() noreturn {
	1365	\\ asm volatile ("syscall"
	1366	\\ :
	1367	\\ : [number] "{rax}" (60), // exit
	1368	\\ [arg1] "{rdi}" (0)
	1369	\\ : "rcx", "r11", "memory"
	1370	\\ );
	1371	\\ unreachable;
	1372	\\}
	1373	,
	1374	"",
	1375	);
	1376	case.addCompareOutput(
	1377	\\pub export fn _start() noreturn {
	1378	\\ asm volatile ("syscall"
	1379	\\ :
	1380	\\ : [number] "{rax}" (231), // exit_group
	1381	\\ [arg1] "{rdi}" (0)
	1382	\\ : "rcx", "r11", "memory"
	1383	\\ );
	1384	\\ unreachable;
	1385	\\}
	1386	,
	1387	"",
	1388	);
	1389	}
	1390	{
	1391	var case = ctx.exe("passing u0 to function", linux_x64);
	1392	case.addCompareOutput(
	1393	\\pub fn main() void {
	1394	\\ doNothing(0);
	1395	\\}
	1396	\\fn doNothing(arg: u0) void {
	1397	\\ _ = arg;
	1398	\\}
	1399	,
	1400	"",
	1401	);
	1402	}
	1403	{
	1404	var case = ctx.exe("catch at comptime", linux_x64);
	1405	case.addCompareOutput(
	1406	\\pub fn main() void {
	1407	\\ const i: anyerror!u64 = 0;
	1408	\\ const caught = i catch 5;
	1409	\\ assert(caught == 0);
	1410	\\}
	1411	\\fn assert(b: bool) void {
	1412	\\ if (!b) unreachable;
	1413	\\}
	1414	,
	1415	"",
	1416	);
	1417
	1418	case.addCompareOutput(
	1419	\\pub fn main() void {
	1420	\\ const i: anyerror!u64 = error.B;
	1421	\\ const caught = i catch 5;
	1422	\\ assert(caught == 5);
	1423	\\}
	1424	\\fn assert(b: bool) void {
	1425	\\ if (!b) unreachable;
	1426	\\}
	1427	,
	1428	"",
	1429	);
	1430
	1431	case.addCompareOutput(
	1432	\\pub fn main() void {
	1433	\\ const a: anyerror!comptime_int = 42;
	1434	\\ const b: *const comptime_int = &(a catch unreachable);
	1435	\\ assert(b.* == 42);
	1436	\\}
	1437	\\fn assert(b: bool) void {
	1438	\\ if (!b) unreachable; // assertion failure
	1439	\\}
	1440	, "");
	1441
	1442	case.addCompareOutput(
	1443	\\pub fn main() void {
	1444	\\ const a: anyerror!u32 = error.B;
	1445	\\ _ = &(a catch \|err\| assert(err == error.B));
	1446	\\}
	1447	\\fn assert(b: bool) void {
	1448	\\ if (!b) unreachable;
	1449	\\}
	1450	, "");
	1451
	1452	case.addCompareOutput(
	1453	\\pub fn main() void {
	1454	\\ const a: anyerror!u32 = error.Bar;
	1455	\\ a catch \|err\| assert(err == error.Bar);
	1456	\\}
	1457	\\fn assert(b: bool) void {
	1458	\\ if (!b) unreachable;
	1459	\\}
	1460	, "");
	1461	}
	1462	{
	1463	var case = ctx.exe("merge error sets", linux_x64);
	1464
	1465	case.addCompareOutput(
	1466	\\pub fn main() void {
	1467	\\ const E = error{ A, B, D } \|\| error { A, B, C };
	1468	\\ E.A catch {};
	1469	\\ E.B catch {};
	1470	\\ E.C catch {};
	1471	\\ E.D catch {};
	1472	\\ const E2 = error { X, Y } \|\| @TypeOf(error.Z);
	1473	\\ E2.X catch {};
	1474	\\ E2.Y catch {};
	1475	\\ E2.Z catch {};
	1476	\\ assert(anyerror \|\| error { Z } == anyerror);
	1477	\\}
	1478	\\fn assert(b: bool) void {
	1479	\\ if (!b) unreachable;
	1480	\\}
	1481	,
	1482	"",
	1483	);
	1484	}
	1485	{
	1486	var case = ctx.exe("inline assembly", linux_x64);
	1487
	1488	case.addError(
	1489	\\pub fn main() void {
	1490	\\ const number = 1234;
	1491	\\ const x = asm volatile ("syscall"
	1492	\\ : [o] "{rax}" (-> number)
	1493	\\ : [number] "{rax}" (231),
	1494	\\ [arg1] "{rdi}" (code)
	1495	\\ : "rcx", "r11", "memory"
	1496	\\ );
	1497	\\ _ = x;
	1498	\\}
	1499	, &[_][]const u8{":4:27: error: expected type, found comptime_int"});
	1500	}
	1501	{
	1502	var case = ctx.exe("comptime var", linux_x64);
	1503
	1504	case.addError(
	1505	\\pub fn main() void {
	1506	\\ var a: u32 = 0;
	1507	\\ comptime var b: u32 = 0;
	1508	\\ if (a == 0) b = 3;
	1509	\\}
	1510	, &.{
	1511	":4:21: error: store to comptime variable depends on runtime condition",
	1512	":4:11: note: runtime condition here",
	1513	});
	1514
	1515	case.addError(
	1516	\\pub fn main() void {
	1517	\\ var a: u32 = 0;
	1518	\\ comptime var b: u32 = 0;
	1519	\\ switch (a) {
	1520	\\ 0 => {},
	1521	\\ else => b = 3,
	1522	\\ }
	1523	\\}
	1524	, &.{
	1525	":6:21: error: store to comptime variable depends on runtime condition",
	1526	":4:13: note: runtime condition here",
	1527	});
	1528
	1529	case.addCompareOutput(
	1530	\\pub fn main() void {
	1531	\\ comptime var len: u32 = 5;
	1532	\\ print(len);
	1533	\\ len += 9;
	1534	\\ print(len);
	1535	\\}
	1536	\\
	1537	\\fn print(len: usize) void {
	1538	\\ asm volatile ("syscall"
	1539	\\ :
	1540	\\ : [number] "{rax}" (1),
	1541	\\ [arg1] "{rdi}" (1),
	1542	\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
	1543	\\ [arg3] "{rdx}" (len)
	1544	\\ : "rcx", "r11", "memory"
	1545	\\ );
	1546	\\ return;
	1547	\\}
	1548	, "HelloHello, World!\n");
	1549
	1550	case.addError(
	1551	\\comptime {
	1552	\\ var x: i32 = 1;
	1553	\\ x += 1;
	1554	\\ if (x != 1) unreachable;
	1555	\\}
	1556	\\pub fn main() void {}
	1557	, &.{":4:17: error: unable to resolve comptime value"});
	1558
	1559	case.addError(
	1560	\\pub fn main() void {
	1561	\\ comptime var i: u64 = 0;
	1562	\\ while (i < 5) : (i += 1) {}
	1563	\\}
	1564	, &.{
	1565	":3:24: error: cannot store to comptime variable in non-inline loop",
	1566	":3:5: note: non-inline loop here",
	1567	});
	1568
	1569	case.addCompareOutput(
	1570	\\pub fn main() void {
	1571	\\ var a: u32 = 0;
	1572	\\ if (a == 0) {
	1573	\\ comptime var b: u32 = 0;
	1574	\\ b = 1;
	1575	\\ }
	1576	\\}
	1577	\\comptime {
	1578	\\ var x: i32 = 1;
	1579	\\ x += 1;
	1580	\\ if (x != 2) unreachable;
	1581	\\}
	1582	, "");
	1583
	1584	case.addCompareOutput(
	1585	\\pub fn main() void {
	1586	\\ comptime var i: u64 = 2;
	1587	\\ inline while (i < 6) : (i+=1) {
	1588	\\ print(i);
	1589	\\ }
	1590	\\}
	1591	\\fn print(len: usize) void {
	1592	\\ asm volatile ("syscall"
	1593	\\ :
	1594	\\ : [number] "{rax}" (1),
	1595	\\ [arg1] "{rdi}" (1),
	1596	\\ [arg2] "{rsi}" (@ptrToInt("Hello")),
	1597	\\ [arg3] "{rdx}" (len)
	1598	\\ : "rcx", "r11", "memory"
	1599	\\ );
	1600	\\ return;
	1601	\\}
	1602	, "HeHelHellHello");
	1603	}
	1604
	1605	{
	1606	var case = ctx.exe("double ampersand", linux_x64);
	1607
	1608	case.addError(
	1609	\\pub const a = if (true && false) 1 else 2;
	1610	, &[_][]const u8{":1:24: error: `&&` is invalid; note that `and` is boolean AND"});
	1611
	1612	case.addError(
	1613	\\pub fn main() void {
	1614	\\ const a = true;
	1615	\\ const b = false;
	1616	\\ _ = a & &b;
	1617	\\}
	1618	, &[_][]const u8{":4:11: error: incompatible types: 'bool' and '*const bool'"});
	1619
	1620	case.addCompareOutput(
	1621	\\pub fn main() void {
	1622	\\ const b: u8 = 1;
	1623	\\ _ = &&b;
	1624	\\}
	1625	, "");
	1626	}
	1627	}

test/compile_errors.zig+1422-1082

...	...	@@ -1,53 +1,58 @@
1		const tests = @import("tests.zig");
2	1	const std = @import("std");
	2	const TestContext = @import("../src/test.zig").TestContext;
3	3
4		pub fn addCases(cases: *tests.CompileErrorContext) void {
5		cases.add("std.fmt error for unused arguments",
	4	pub fn addCases(ctx: *TestContext) !void {
	5	ctx.exeErrStage1("std.fmt error for unused arguments",
6	6	\\pub fn main() !void {
7	7	\\ @import("std").debug.print("{d} {d} {d} {d} {d}", .{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15});
8	8	\\}
9	9	, &.{
10		\\error: 10 unused arguments in "{d} {d} {d} {d} {d}"
	10	"?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'",
11	11	});
12	12
13		cases.add("lazy pointer with undefined element type",
	13	ctx.objErrStage1("lazy pointer with undefined element type",
14	14	\\export fn foo() void {
15	15	\\ comptime var T: type = undefined;
16	16	\\ const S = struct { x: *T };
17	17	\\ const I = @typeInfo(S);
	18	\\ _ = I;
18	19	\\}
19	20	, &[_][]const u8{
20		"tmp.zig:3:28: error: use of undefined value here causes undefined behavior",
	21	":3:28: error: use of undefined value here causes undefined behavior",
21	22	});
22	23
23		cases.add("pointer arithmetic on pointer-to-array",
	24	ctx.objErrStage1("pointer arithmetic on pointer-to-array",
24	25	\\export fn foo() void {
25	26	\\ var x: [10]u8 = undefined;
26	27	\\ var y = &x;
27	28	\\ var z = y + 1;
	29	\\ _ = z;
28	30	\\}
29	31	, &[_][]const u8{
30	32	"tmp.zig:4:17: error: integer value 1 cannot be coerced to type '*[10]u8'",
31	33	});
32	34
33		cases.add("pointer attributes checked when coercing pointer to anon literal",
	35	ctx.objErrStage1("pointer attributes checked when coercing pointer to anon literal",
34	36	\\comptime {
35	37	\\ const c: [][]const u8 = &.{"hello", "world" };
	38	\\ _ = c;
36	39	\\}
37	40	\\comptime {
38	41	\\ const c: *[2][]const u8 = &.{"hello", "world" };
	42	\\ _ = c;
39	43	\\}
40	44	\\const S = struct {a: u8 = 1, b: u32 = 2};
41	45	\\comptime {
42	46	\\ const c: *S = &.{};
	47	\\ _ = c;
43	48	\\}
44	49	, &[_][]const u8{
45	50	"tmp.zig:2:31: error: expected type '[][]const u8', found '*const struct:2:31'",
46		"tmp.zig:5:33: error: expected type '[2][]const u8', found 'const struct:5:33'",
47		"tmp.zig:9:21: error: expected type 'S', found 'const struct:9:21'",
	51	"tmp.zig:6:33: error: expected type '[2][]const u8', found 'const struct:6:33'",
	52	"tmp.zig:11:21: error: expected type 'S', found 'const struct:11:21'",
48	53	});
49	54
50		cases.add("@Type() union payload is undefined",
	55	ctx.objErrStage1("@Type() union payload is undefined",
51	56	\\const Foo = @Type(@import("std").builtin.TypeInfo{
52	57	\\ .Struct = undefined,
53	58	\\});
...	...	@@ -56,7 +61,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
56	61	"tmp.zig:1:50: error: use of undefined value here causes undefined behavior",
57	62	});
58	63
59		cases.add("wrong initializer for union payload of type 'type'",
	64	ctx.objErrStage1("wrong initializer for union payload of type 'type'",
60	65	\\const U = union(enum) {
61	66	\\ A: type,
62	67	\\};
...	...	@@ -71,7 +76,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
71	76	"tmp.zig:9:8: error: use of undefined value here causes undefined behavior",
72	77	});
73	78
74		cases.add("union with too small explicit signed tag type",
	79	ctx.objErrStage1("union with too small explicit signed tag type",
75	80	\\const U = union(enum(i2)) {
76	81	\\ A: u8,
77	82	\\ B: u8,
...	...	@@ -86,7 +91,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
86	91	"tmp.zig:1:22: note: type i2 cannot fit values in range 0...3",
87	92	});
88	93
89		cases.add("union with too small explicit unsigned tag type",
	94	ctx.objErrStage1("union with too small explicit unsigned tag type",
90	95	\\const U = union(enum(u2)) {
91	96	\\ A: u8,
92	97	\\ B: u8,
...	...	@@ -102,56 +107,60 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
102	107	"tmp.zig:1:22: note: type u2 cannot fit values in range 0...4",
103	108	});
104	109
105		cases.addCase(x: {
106		var tc = cases.create("callconv(.Interrupt) on unsupported platform",
	110	{
	111	const case = ctx.obj("callconv(.Interrupt) on unsupported platform", .{
	112	.cpu_arch = .aarch64,
	113	.os_tag = .linux,
	114	.abi = .none,
	115	});
	116	case.backend = .stage1;
	117	case.addError(
107	118	\\export fn entry() callconv(.Interrupt) void {}
108	119	, &[_][]const u8{
109	120	"tmp.zig:1:28: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64",
110	121	});
111		tc.target = std.zig.CrossTarget{
112		.cpu_arch = .aarch64,
	122	}
	123	{
	124	var case = ctx.obj("callconv(.Signal) on unsupported platform", .{
	125	.cpu_arch = .x86_64,
113	126	.os_tag = .linux,
114	127	.abi = .none,
115		};
116		break :x tc;
117		});
118
119		cases.addCase(x: {
120		var tc = cases.create("callconv(.Signal) on unsupported platform",
	128	});
	129	case.backend = .stage1;
	130	case.addError(
121	131	\\export fn entry() callconv(.Signal) void {}
122	132	, &[_][]const u8{
123	133	"tmp.zig:1:28: error: callconv 'Signal' is only available on AVR, not x86_64",
124	134	});
125		tc.target = std.zig.CrossTarget{
	135	}
	136	{
	137	const case = ctx.obj("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform", .{
126	138	.cpu_arch = .x86_64,
127	139	.os_tag = .linux,
128	140	.abi = .none,
129		};
130		break :x tc;
131		});
132		cases.addCase(x: {
133		var tc = cases.create("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform",
	141	});
	142	case.backend = .stage1;
	143	case.addError(
134	144	\\const F1 = fn () callconv(.Stdcall) void;
135	145	\\const F2 = fn () callconv(.Fastcall) void;
136	146	\\const F3 = fn () callconv(.Thiscall) void;
137		\\export fn entry1() void { var a: F1 = undefined; }
138		\\export fn entry2() void { var a: F2 = undefined; }
139		\\export fn entry3() void { var a: F3 = undefined; }
	147	\\export fn entry1() void { var a: F1 = undefined; _ = a; }
	148	\\export fn entry2() void { var a: F2 = undefined; _ = a; }
	149	\\export fn entry3() void { var a: F3 = undefined; _ = a; }
140	150	, &[_][]const u8{
141	151	"tmp.zig:1:27: error: callconv 'Stdcall' is only available on x86, not x86_64",
142	152	"tmp.zig:2:27: error: callconv 'Fastcall' is only available on x86, not x86_64",
143	153	"tmp.zig:3:27: error: callconv 'Thiscall' is only available on x86, not x86_64",
144	154	});
145		tc.target = std.zig.CrossTarget{
	155	}
	156	{
	157	const case = ctx.obj("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform", .{
146	158	.cpu_arch = .x86_64,
147	159	.os_tag = .linux,
148	160	.abi = .none,
149		};
150		break :x tc;
151		});
152
153		cases.addCase(x: {
154		var tc = cases.create("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform",
	161	});
	162	case.backend = .stage1;
	163	case.addError(
155	164	\\export fn entry1() callconv(.Stdcall) void {}
156	165	\\export fn entry2() callconv(.Fastcall) void {}
157	166	\\export fn entry3() callconv(.Thiscall) void {}
...	...	@@ -160,30 +169,28 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
160	169	"tmp.zig:2:29: error: callconv 'Fastcall' is only available on x86, not x86_64",
161	170	"tmp.zig:3:29: error: callconv 'Thiscall' is only available on x86, not x86_64",
162	171	});
163		tc.target = std.zig.CrossTarget{
	172	}
	173	{
	174	const case = ctx.obj("callconv(.Vectorcall) on unsupported platform", .{
164	175	.cpu_arch = .x86_64,
165	176	.os_tag = .linux,
166	177	.abi = .none,
167		};
168		break :x tc;
169		});
170
171		cases.addCase(x: {
172		var tc = cases.create("callconv(.Vectorcall) on unsupported platform",
	178	});
	179	case.backend = .stage1;
	180	case.addError(
173	181	\\export fn entry() callconv(.Vectorcall) void {}
174	182	, &[_][]const u8{
175	183	"tmp.zig:1:28: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64",
176	184	});
177		tc.target = std.zig.CrossTarget{
	185	}
	186	{
	187	const case = ctx.obj("callconv(.APCS, .AAPCS, .AAPCSVFP) on unsupported platform", .{
178	188	.cpu_arch = .x86_64,
179	189	.os_tag = .linux,
180	190	.abi = .none,
181		};
182		break :x tc;
183		});
184
185		cases.addCase(x: {
186		var tc = cases.create("callconv(.APCS, .AAPCS, .AAPCSVFP) on unsupported platform",
	191	});
	192	case.backend = .stage1;
	193	case.addError(
187	194	\\export fn entry1() callconv(.APCS) void {}
188	195	\\export fn entry2() callconv(.AAPCS) void {}
189	196	\\export fn entry3() callconv(.AAPCSVFP) void {}
...	...	@@ -192,15 +199,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
192	199	"tmp.zig:2:29: error: callconv 'AAPCS' is only available on ARM, not x86_64",
193	200	"tmp.zig:3:29: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64",
194	201	});
195		tc.target = std.zig.CrossTarget{
196		.cpu_arch = .x86_64,
197		.os_tag = .linux,
198		.abi = .none,
199		};
200		break :x tc;
201		});
	202	}
202	203
203		cases.add("unreachable executed at comptime",
	204	ctx.objErrStage1("unreachable executed at comptime",
204	205	\\fn foo(comptime x: i32) i32 {
205	206	\\ comptime {
206	207	\\ if (x >= 0) return -x;
...	...	@@ -215,7 +216,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
215	216	"tmp.zig:8:12: note: called from here",
216	217	});
217	218
218		cases.add("@Type with TypeInfo.Int",
	219	ctx.objErrStage1("@Type with TypeInfo.Int",
219	220	\\const builtin = @import("std").builtin;
220	221	\\export fn entry() void {
221	222	\\ _ = @Type(builtin.TypeInfo.Int {
...	...	@@ -227,7 +228,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
227	228	"tmp.zig:3:36: error: expected type 'std.builtin.TypeInfo', found 'std.builtin.Int'",
228	229	});
229	230
230		cases.add("indexing a undefined slice at comptime",
	231	ctx.objErrStage1("indexing a undefined slice at comptime",
231	232	\\comptime {
232	233	\\ var slice: []u8 = undefined;
233	234	\\ slice[0] = 2;
...	...	@@ -236,7 +237,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
236	237	"tmp.zig:3:10: error: index 0 outside slice of size 0",
237	238	});
238	239
239		cases.add("array in c exported function",
	240	ctx.objErrStage1("array in c exported function",
240	241	\\export fn zig_array(x: [10]u8) void {
241	242	\\try expect(std.mem.eql(u8, &x, "1234567890"));
242	243	\\}
...	...	@@ -249,7 +250,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
249	250	"tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'",
250	251	});
251	252
252		cases.add("@Type for exhaustive enum with undefined tag type",
	253	ctx.objErrStage1("@Type for exhaustive enum with undefined tag type",
253	254	\\const TypeInfo = @import("std").builtin.TypeInfo;
254	255	\\const Tag = @Type(.{
255	256	\\ .Enum = .{
...	...	@@ -267,19 +268,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
267	268	"tmp.zig:2:20: error: use of undefined value here causes undefined behavior",
268	269	});
269	270
270		cases.add("extern struct with non-extern-compatible integer tag type",
	271	ctx.objErrStage1("extern struct with non-extern-compatible integer tag type",
271	272	\\pub const E = enum(u31) { A, B, C };
272	273	\\pub const S = extern struct {
273	274	\\ e: E,
274	275	\\};
275	276	\\export fn entry() void {
276	277	\\ const s: S = undefined;
	278	\\ _ = s;
277	279	\\}
278	280	, &[_][]const u8{
279	281	"tmp.zig:3:5: error: extern structs cannot contain fields of type 'E'",
280	282	});
281	283
282		cases.add("@Type for exhaustive enum with non-integer tag type",
	284	ctx.objErrStage1("@Type for exhaustive enum with non-integer tag type",
283	285	\\const TypeInfo = @import("std").builtin.TypeInfo;
284	286	\\const Tag = @Type(.{
285	287	\\ .Enum = .{
...	...	@@ -297,7 +299,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
297	299	"tmp.zig:2:20: error: TypeInfo.Enum.tag_type must be an integer type, not 'bool'",
298	300	});
299	301
300		cases.add("extern struct with extern-compatible but inferred integer tag type",
	302	ctx.objErrStage1("extern struct with extern-compatible but inferred integer tag type",
301	303	\\pub const E = enum {
302	304	\\@"0",@"1",@"2",@"3",@"4",@"5",@"6",@"7",@"8",@"9",@"10",@"11",@"12",
303	305	\\@"13",@"14",@"15",@"16",@"17",@"18",@"19",@"20",@"21",@"22",@"23",
...	...	@@ -333,12 +335,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
333	335	\\export fn entry() void {
334	336	\\ if (@typeInfo(E).Enum.tag_type != u8) @compileError("did not infer u8 tag type");
335	337	\\ const s: S = undefined;
	338	\\ _ = s;
336	339	\\}
337	340	, &[_][]const u8{
338	341	"tmp.zig:31:5: error: extern structs cannot contain fields of type 'E'",
339	342	});
340	343
341		cases.add("@Type for tagged union with extra enum field",
	344	ctx.objErrStage1("@Type for tagged union with extra enum field",
342	345	\\const TypeInfo = @import("std").builtin.TypeInfo;
343	346	\\const Tag = @Type(.{
344	347	\\ .Enum = .{
...	...	@@ -373,7 +376,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
373	376	"tmp.zig:27:24: note: referenced here",
374	377	});
375	378
376		cases.add("field access of opaque type",
	379	ctx.objErrStage1("field access of opaque type",
377	380	\\const MyType = opaque {};
378	381	\\
379	382	\\export fn entry() bool {
...	...	@@ -388,16 +391,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
388	391	"tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'",
389	392	});
390	393
391		cases.add("opaque type with field",
	394	ctx.objErrStage1("opaque type with field",
392	395	\\const Opaque = opaque { foo: i32 };
393	396	\\export fn entry() void {
394	397	\\ const foo: ?*Opaque = null;
	398	\\ _ = foo;
395	399	\\}
396	400	, &[_][]const u8{
397	401	"tmp.zig:1:25: error: opaque types cannot have fields",
398	402	});
399	403
400		cases.add("@Type(.Fn) with is_generic = true",
	404	ctx.objErrStage1("@Type(.Fn) with is_generic = true",
401	405	\\const Foo = @Type(.{
402	406	\\ .Fn = .{
403	407	\\ .calling_convention = .Unspecified,
...	...	@@ -413,7 +417,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
413	417	"tmp.zig:1:20: error: TypeInfo.Fn.is_generic must be false for @Type",
414	418	});
415	419
416		cases.add("@Type(.Fn) with is_var_args = true and non-C callconv",
	420	ctx.objErrStage1("@Type(.Fn) with is_var_args = true and non-C callconv",
417	421	\\const Foo = @Type(.{
418	422	\\ .Fn = .{
419	423	\\ .calling_convention = .Unspecified,
...	...	@@ -429,7 +433,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
429	433	"tmp.zig:1:20: error: varargs functions must have C calling convention",
430	434	});
431	435
432		cases.add("@Type(.Fn) with return_type = null",
	436	ctx.objErrStage1("@Type(.Fn) with return_type = null",
433	437	\\const Foo = @Type(.{
434	438	\\ .Fn = .{
435	439	\\ .calling_convention = .Unspecified,
...	...	@@ -445,7 +449,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
445	449	"tmp.zig:1:20: error: TypeInfo.Fn.return_type must be non-null for @Type",
446	450	});
447	451
448		cases.add("@Type for union with opaque field",
	452	ctx.objErrStage1("@Type for union with opaque field",
449	453	\\const TypeInfo = @import("std").builtin.TypeInfo;
450	454	\\const Untagged = @Type(.{
451	455	\\ .Union = .{
...	...	@@ -465,23 +469,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
465	469	"tmp.zig:13:17: note: referenced here",
466	470	});
467	471
468		cases.add("slice sentinel mismatch",
	472	ctx.objErrStage1("slice sentinel mismatch",
469	473	\\export fn entry() void {
470	474	\\ const x = @import("std").meta.Vector(3, f32){ 25, 75, 5, 0 };
	475	\\ _ = x;
471	476	\\}
472	477	, &[_][]const u8{
473	478	"tmp.zig:2:62: error: index 3 outside vector of size 3",
474	479	});
475	480
476		cases.add("slice sentinel mismatch",
	481	ctx.objErrStage1("slice sentinel mismatch",
477	482	\\export fn entry() void {
478	483	\\ const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
	484	\\ _ = y;
479	485	\\}
480	486	, &[_][]const u8{
481	487	"tmp.zig:2:37: error: expected type '[:1]const u8', found '*const [2:2]u8'",
482	488	});
483	489
484		cases.add("@Type for union with zero fields",
	490	ctx.objErrStage1("@Type for union with zero fields",
485	491	\\const TypeInfo = @import("std").builtin.TypeInfo;
486	492	\\const Untagged = @Type(.{
487	493	\\ .Union = .{
...	...	@@ -499,7 +505,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
499	505	"tmp.zig:11:17: note: referenced here",
500	506	});
501	507
502		cases.add("@Type for exhaustive enum with zero fields",
	508	ctx.objErrStage1("@Type for exhaustive enum with zero fields",
503	509	\\const TypeInfo = @import("std").builtin.TypeInfo;
504	510	\\const Tag = @Type(.{
505	511	\\ .Enum = .{
...	...	@@ -518,7 +524,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
518	524	"tmp.zig:12:9: note: referenced here",
519	525	});
520	526
521		cases.add("@Type for tagged union with extra union field",
	527	ctx.objErrStage1("@Type for tagged union with extra union field",
522	528	\\const TypeInfo = @import("std").builtin.TypeInfo;
523	529	\\const Tag = @Type(.{
524	530	\\ .Enum = .{
...	...	@@ -554,7 +560,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
554	560	"tmp.zig:27:24: note: referenced here",
555	561	});
556	562
557		cases.add("@Type with undefined",
	563	ctx.objErrStage1("@Type with undefined",
558	564	\\comptime {
559	565	\\ _ = @Type(.{ .Array = .{ .len = 0, .child = u8, .sentinel = undefined } });
560	566	\\}
...	...	@@ -573,7 +579,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
573	579	"tmp.zig:5:16: error: use of undefined value here causes undefined behavior",
574	580	});
575	581
576		cases.add("struct with declarations unavailable for @Type",
	582	ctx.objErrStage1("struct with declarations unavailable for @Type",
577	583	\\export fn entry() void {
578	584	\\ _ = @Type(@typeInfo(struct { const foo = 1; }));
579	585	\\}
...	...	@@ -581,7 +587,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
581	587	"tmp.zig:2:15: error: TypeInfo.Struct.decls must be empty for @Type",
582	588	});
583	589
584		cases.add("enum with declarations unavailable for @Type",
	590	ctx.objErrStage1("enum with declarations unavailable for @Type",
585	591	\\export fn entry() void {
586	592	\\ _ = @Type(@typeInfo(enum { foo, const bar = 1; }));
587	593	\\}
...	...	@@ -589,36 +595,44 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
589	595	"tmp.zig:2:15: error: TypeInfo.Enum.decls must be empty for @Type",
590	596	});
591	597
592		cases.addTest("reject extern variables with initializers",
	598	ctx.testErrStage1("reject extern variables with initializers",
593	599	\\extern var foo: int = 2;
594	600	, &[_][]const u8{
595		"tmp.zig:1:1: error: extern variables have no initializers",
	601	"tmp.zig:1:23: error: extern variables have no initializers",
596	602	});
597	603
598		cases.addTest("duplicate/unused labels",
	604	ctx.testErrStage1("duplicate/unused labels",
599	605	\\comptime {
600	606	\\ blk: { blk: while (false) {} }
	607	\\}
	608	\\comptime {
601	609	\\ blk: while (false) { blk: for (@as([0]void, undefined)) \|_\| {} }
	610	\\}
	611	\\comptime {
602	612	\\ blk: for (@as([0]void, undefined)) \|_\| { blk: {} }
603	613	\\}
604	614	\\comptime {
605	615	\\ blk: {}
	616	\\}
	617	\\comptime {
606	618	\\ blk: while(false) {}
	619	\\}
	620	\\comptime {
607	621	\\ blk: for(@as([0]void, undefined)) \|_\| {}
608	622	\\}
609	623	, &[_][]const u8{
610		"tmp.zig:2:17: error: redeclaration of label 'blk'",
611		"tmp.zig:2:10: note: previous declaration is here",
612		"tmp.zig:3:31: error: redeclaration of label 'blk'",
613		"tmp.zig:3:10: note: previous declaration is here",
614		"tmp.zig:4:51: error: redeclaration of label 'blk'",
615		"tmp.zig:4:10: note: previous declaration is here",
616		"tmp.zig:7:10: error: unused block label",
617		"tmp.zig:8:10: error: unused while label",
618		"tmp.zig:9:10: error: unused for label",
	624	"tmp.zig:2:12: error: redefinition of label 'blk'",
	625	"tmp.zig:2:5: note: previous definition here",
	626	"tmp.zig:5:26: error: redefinition of label 'blk'",
	627	"tmp.zig:5:5: note: previous definition here",
	628	"tmp.zig:8:46: error: redefinition of label 'blk'",
	629	"tmp.zig:8:5: note: previous definition here",
	630	"tmp.zig:11:5: error: unused block label",
	631	"tmp.zig:14:5: error: unused while loop label",
	632	"tmp.zig:17:5: error: unused for loop label",
619	633	});
620	634
621		cases.addTest("@alignCast of zero sized types",
	635	ctx.testErrStage1("@alignCast of zero sized types",
622	636	\\export fn foo() void {
623	637	\\ const a: *void = undefined;
624	638	\\ _ = @alignCast(2, a);
...	...	@@ -633,7 +647,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
633	647	\\}
634	648	\\export fn qux() void {
635	649	\\ const a = struct {
636		\\ fn a(comptime b: u32) void {}
	650	\\ fn a(comptime b: u32) void { _ = b; }
637	651	\\ }.a;
638	652	\\ _ = @alignCast(2, a);
639	653	\\}
...	...	@@ -644,7 +658,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
644	658	"tmp.zig:17:23: error: cannot adjust alignment of zero sized type 'fn(u32) anytype'",
645	659	});
646	660
647		cases.addTest("invalid non-exhaustive enum to union",
	661	ctx.testErrStage1("invalid non-exhaustive enum to union",
648	662	\\const E = enum(u8) {
649	663	\\ a,
650	664	\\ b,
...	...	@@ -657,17 +671,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
657	671	\\export fn foo() void {
658	672	\\ var e = @intToEnum(E, 15);
659	673	\\ var u: U = e;
	674	\\ _ = u;
660	675	\\}
661	676	\\export fn bar() void {
662	677	\\ const e = @intToEnum(E, 15);
663	678	\\ var u: U = e;
	679	\\ _ = u;
664	680	\\}
665	681	, &[_][]const u8{
666	682	"tmp.zig:12:16: error: runtime cast to union 'U' from non-exhustive enum",
667		"tmp.zig:16:16: error: no tag by value 15",
	683	"tmp.zig:17:16: error: no tag by value 15",
668	684	});
669	685
670		cases.addTest("switching with exhaustive enum has '_' prong ",
	686	ctx.testErrStage1("switching with exhaustive enum has '_' prong ",
671	687	\\const E = enum{
672	688	\\ a,
673	689	\\ b,
...	...	@@ -684,7 +700,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
684	700	"tmp.zig:7:5: error: switch on exhaustive enum has `_` prong",
685	701	});
686	702
687		cases.addTest("invalid pointer with @Type",
	703	ctx.testErrStage1("invalid pointer with @Type",
688	704	\\export fn entry() void {
689	705	\\ _ = @Type(.{ .Pointer = .{
690	706	\\ .size = .One,
...	...	@@ -700,7 +716,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
700	716	"tmp.zig:2:16: error: sentinels are only allowed on slices and unknown-length pointers",
701	717	});
702	718
703		cases.addTest("helpful return type error message",
	719	ctx.testErrStage1("helpful return type error message",
704	720	\\export fn foo() u32 {
705	721	\\ return error.Ohno;
706	722	\\}
...	...	@@ -728,7 +744,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
728	744	"tmp.zig:14:5: note: cannot store an error in type 'u32'",
729	745	});
730	746
731		cases.addTest("int/float conversion to comptime_int/float",
	747	ctx.testErrStage1("int/float conversion to comptime_int/float",
732	748	\\export fn foo() void {
733	749	\\ var a: f32 = 2;
734	750	\\ _ = @floatToInt(comptime_int, a);
...	...	@@ -744,16 +760,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
744	760	"tmp.zig:7:9: note: referenced here",
745	761	});
746	762
747		cases.add("extern variable has no type",
	763	ctx.objErrStage1("extern variable has no type",
748	764	\\extern var foo;
749	765	\\pub export fn entry() void {
750	766	\\ foo;
751	767	\\}
752	768	, &[_][]const u8{
753		"tmp.zig:1:1: error: unable to infer variable type",
	769	"tmp.zig:1:8: error: unable to infer variable type",
754	770	});
755	771
756		cases.add("@src outside function",
	772	ctx.objErrStage1("@src outside function",
757	773	\\comptime {
758	774	\\ @src();
759	775	\\}
...	...	@@ -761,7 +777,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
761	777	"tmp.zig:2:5: error: @src outside function",
762	778	});
763	779
764		cases.add("call assigned to constant",
	780	ctx.objErrStage1("call assigned to constant",
765	781	\\const Foo = struct {
766	782	\\ x: i32,
767	783	\\};
...	...	@@ -784,15 +800,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
784	800	"tmp.zig:16:14: error: cannot assign to constant",
785	801	});
786	802
787		cases.add("invalid pointer syntax",
	803	ctx.objErrStage1("invalid pointer syntax",
788	804	\\export fn foo() void {
789	805	\\ var guid: *:0 const u8 = undefined;
790	806	\\}
791	807	, &[_][]const u8{
792		"tmp.zig:2:15: error: sentinels are only allowed on unknown-length pointers",
	808	"tmp.zig:2:16: error: expected type expression, found ':'",
793	809	});
794	810
795		cases.add("declaration between fields",
	811	ctx.objErrStage1("declaration between fields",
796	812	\\const S = struct {
797	813	\\ const foo = 2;
798	814	\\ const bar = 2;
...	...	@@ -810,16 +826,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
810	826	"tmp.zig:6:5: error: declarations are not allowed between container fields",
811	827	});
812	828
813		cases.add("non-extern function with var args",
	829	ctx.objErrStage1("non-extern function with var args",
814	830	\\fn foo(args: ...) void {}
815	831	\\export fn entry() void {
816	832	\\ foo();
817	833	\\}
818	834	, &[_][]const u8{
819		"tmp.zig:1:1: error: non-extern function is variadic",
	835	"tmp.zig:1:14: error: expected type expression, found '...'",
820	836	});
821	837
822		cases.addTest("invalid int casts",
	838	ctx.testErrStage1("invalid int casts",
823	839	\\export fn foo() void {
824	840	\\ var a: u32 = 2;
825	841	\\ _ = @intCast(comptime_int, a);
...	...	@@ -847,7 +863,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
847	863	"tmp.zig:15:9: note: referenced here",
848	864	});
849	865
850		cases.addTest("invalid float casts",
	866	ctx.testErrStage1("invalid float casts",
851	867	\\export fn foo() void {
852	868	\\ var a: f32 = 2;
853	869	\\ _ = @floatCast(comptime_float, a);
...	...	@@ -875,7 +891,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
875	891	"tmp.zig:15:9: note: referenced here",
876	892	});
877	893
878		cases.addTest("invalid assignments",
	894	ctx.testErrStage1("invalid assignments",
879	895	\\export fn entry1() void {
880	896	\\ var a: []const u8 = "foo";
881	897	\\ a[0..2] = "bar";
...	...	@@ -893,7 +909,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
893	909	"tmp.zig:10:7: error: invalid left-hand side to assignment",
894	910	});
895	911
896		cases.addTest("reassign to array parameter",
	912	ctx.testErrStage1("reassign to array parameter",
897	913	\\fn reassign(a: [3]f32) void {
898	914	\\ a = [3]f32{4, 5, 6};
899	915	\\}
...	...	@@ -904,7 +920,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
904	920	"tmp.zig:2:15: error: cannot assign to constant",
905	921	});
906	922
907		cases.addTest("reassign to slice parameter",
	923	ctx.testErrStage1("reassign to slice parameter",
908	924	\\pub fn reassign(s: []const u8) void {
909	925	\\ s = s[0..];
910	926	\\}
...	...	@@ -915,7 +931,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
915	931	"tmp.zig:2:10: error: cannot assign to constant",
916	932	});
917	933
918		cases.addTest("reassign to struct parameter",
	934	ctx.testErrStage1("reassign to struct parameter",
919	935	\\const S = struct {
920	936	\\ x: u32,
921	937	\\};
...	...	@@ -929,7 +945,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
929	945	"tmp.zig:5:10: error: cannot assign to constant",
930	946	});
931	947
932		cases.addTest("reference to const data",
	948	ctx.testErrStage1("reference to const data",
933	949	\\export fn foo() void {
934	950	\\ var ptr = &[_]u8{0,0,0,0};
935	951	\\ ptr[1] = 2;
...	...	@@ -957,7 +973,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
957	973	"tmp.zig:19:13: error: cannot assign to constant",
958	974	});
959	975
960		cases.addTest("cast between ?T where T is not a pointer",
	976	ctx.testErrStage1("cast between ?T where T is not a pointer",
961	977	\\pub const fnty1 = ?fn (i8) void;
962	978	\\pub const fnty2 = ?fn (u64) void;
963	979	\\export fn entry() void {
...	...	@@ -970,7 +986,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
970	986	"tmp.zig:6:9: note: optional type child 'fn(u64) void' cannot cast into optional type child 'fn(i8) void'",
971	987	});
972	988
973		cases.addTest("unused variable error on errdefer",
	989	ctx.testErrStage1("unused variable error on errdefer",
974	990	\\fn foo() !void {
975	991	\\ errdefer \|a\| unreachable;
976	992	\\ return error.A;
...	...	@@ -982,18 +998,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
982	998	"tmp.zig:2:15: error: unused variable: 'a'",
983	999	});
984	1000
985		cases.addTest("comparison of non-tagged union and enum literal",
	1001	ctx.testErrStage1("comparison of non-tagged union and enum literal",
986	1002	\\export fn entry() void {
987	1003	\\ const U = union { A: u32, B: u64 };
988	1004	\\ var u = U{ .A = 42 };
989	1005	\\ var ok = u == .A;
	1006	\\ _ = ok;
990	1007	\\}
991	1008	, &[_][]const u8{
992	1009	"tmp.zig:4:16: error: comparison of union and enum literal is only valid for tagged union types",
993	1010	"tmp.zig:2:15: note: type U is not a tagged union",
994	1011	});
995	1012
996		cases.addTest("shift on type with non-power-of-two size",
	1013	ctx.testErrStage1("shift on type with non-power-of-two size",
997	1014	\\export fn entry() void {
998	1015	\\ const S = struct {
999	1016	\\ fn a() void {
...	...	@@ -1025,7 +1042,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1025	1042	"tmp.zig:17:17: error: RHS of shift is too large for LHS type",
1026	1043	});
1027	1044
1028		cases.addTest("combination of nosuspend and async",
	1045	ctx.testErrStage1("combination of nosuspend and async",
1029	1046	\\export fn entry() void {
1030	1047	\\ nosuspend {
1031	1048	\\ const bar = async foo();
...	...	@@ -1035,10 +1052,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1035	1052	\\}
1036	1053	\\fn foo() void {}
1037	1054	, &[_][]const u8{
1038		"tmp.zig:4:9: error: suspend in nosuspend scope",
	1055	"tmp.zig:4:9: error: suspend inside nosuspend block",
	1056	"tmp.zig:2:5: note: nosuspend block here",
1039	1057	});
1040	1058
1041		cases.add("atomicrmw with bool op not .Xchg",
	1059	ctx.objErrStage1("atomicrmw with bool op not .Xchg",
1042	1060	\\export fn entry() void {
1043	1061	\\ var x = false;
1044	1062	\\ _ = @atomicRmw(bool, &x, .Add, true, .SeqCst);
...	...	@@ -1047,7 +1065,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1047	1065	"tmp.zig:3:30: error: @atomicRmw with bool only allowed with .Xchg",
1048	1066	});
1049	1067
1050		cases.addTest("@TypeOf with no arguments",
	1068	ctx.testErrStage1("@TypeOf with no arguments",
1051	1069	\\export fn entry() void {
1052	1070	\\ _ = @TypeOf();
1053	1071	\\}
...	...	@@ -1055,7 +1073,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1055	1073	"tmp.zig:2:9: error: expected at least 1 argument, found 0",
1056	1074	});
1057	1075
1058		cases.addTest("@TypeOf with incompatible arguments",
	1076	ctx.testErrStage1("@TypeOf with incompatible arguments",
1059	1077	\\export fn entry() void {
1060	1078	\\ var var_1: f32 = undefined;
1061	1079	\\ var var_2: u32 = undefined;
...	...	@@ -1065,7 +1083,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1065	1083	"tmp.zig:4:9: error: incompatible types: 'f32' and 'u32'",
1066	1084	});
1067	1085
1068		cases.addTest("type mismatch with tuple concatenation",
	1086	ctx.testErrStage1("type mismatch with tuple concatenation",
1069	1087	\\export fn entry() void {
1070	1088	\\ var x = .{};
1071	1089	\\ x = x ++ .{ 1, 2, 3 };
...	...	@@ -1074,7 +1092,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1074	1092	"tmp.zig:3:11: error: expected type 'struct:2:14', found 'struct:3:11'",
1075	1093	});
1076	1094
1077		cases.addTest("@tagName on invalid value of non-exhaustive enum",
	1095	ctx.testErrStage1("@tagName on invalid value of non-exhaustive enum",
1078	1096	\\test "enum" {
1079	1097	\\ const E = enum(u8) {A, B, _};
1080	1098	\\ _ = @tagName(@intToEnum(E, 5));
...	...	@@ -1083,16 +1101,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1083	1101	"tmp.zig:3:18: error: no tag by value 5",
1084	1102	});
1085	1103
1086		cases.addTest("@ptrToInt with pointer to zero-sized type",
	1104	ctx.testErrStage1("@ptrToInt with pointer to zero-sized type",
1087	1105	\\export fn entry() void {
1088	1106	\\ var pointer: ?*u0 = null;
1089	1107	\\ var x = @ptrToInt(pointer);
	1108	\\ _ = x;
1090	1109	\\}
1091	1110	, &[_][]const u8{
1092	1111	"tmp.zig:3:23: error: pointer to size 0 type has no address",
1093	1112	});
1094	1113
1095		cases.addTest("access invalid @typeInfo decl",
	1114	ctx.testErrStage1("access invalid @typeInfo decl",
1096	1115	\\const A = B;
1097	1116	\\test "Crash" {
1098	1117	\\ _ = @typeInfo(@This()).Struct.decls[0];
...	...	@@ -1101,7 +1120,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1101	1120	"tmp.zig:1:11: error: use of undeclared identifier 'B'",
1102	1121	});
1103	1122
1104		cases.addTest("reject extern function definitions with body",
	1123	ctx.testErrStage1("reject extern function definitions with body",
1105	1124	\\extern "c" fn definitelyNotInLibC(a: i32, b: i32) i32 {
1106	1125	\\ return a + b;
1107	1126	\\}
...	...	@@ -1109,7 +1128,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1109	1128	"tmp.zig:1:1: error: extern functions have no body",
1110	1129	});
1111	1130
1112		cases.addTest("duplicate field in anonymous struct literal",
	1131	ctx.testErrStage1("duplicate field in anonymous struct literal",
1113	1132	\\export fn entry() void {
1114	1133	\\ const anon = .{
1115	1134	\\ .inner = .{
...	...	@@ -1119,31 +1138,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1119	1138	\\ .a = .{},
1120	1139	\\ },
1121	1140	\\ };
	1141	\\ _ = anon;
1122	1142	\\}
1123	1143	, &[_][]const u8{
1124	1144	"tmp.zig:7:13: error: duplicate field",
1125	1145	"tmp.zig:4:13: note: other field here",
1126	1146	});
1127	1147
1128		cases.addTest("type mismatch in C prototype with varargs",
	1148	ctx.testErrStage1("type mismatch in C prototype with varargs",
1129	1149	\\const fn_ty = ?fn ([*c]u8, ...) callconv(.C) void;
1130	1150	\\extern fn fn_decl(fmt: [*:0]u8, ...) void;
1131	1151	\\
1132	1152	\\export fn main() void {
1133	1153	\\ const x: fn_ty = fn_decl;
	1154	\\ _ = x;
1134	1155	\\}
1135	1156	, &[_][]const u8{
1136	1157	"tmp.zig:5:22: error: expected type 'fn([c]u8, ...) callconv(.C) void', found 'fn([:0]u8, ...) callconv(.C) void'",
1137	1158	});
1138	1159
1139		cases.addTest("dependency loop in top-level decl with @TypeInfo when accessing the decls",
	1160	ctx.testErrStage1("dependency loop in top-level decl with @TypeInfo when accessing the decls",
1140	1161	\\export const foo = @typeInfo(@This()).Struct.decls;
1141	1162	, &[_][]const u8{
1142	1163	"tmp.zig:1:20: error: dependency loop detected",
1143	1164	"tmp.zig:1:45: note: referenced here",
1144	1165	});
1145	1166
1146		cases.add("function call assigned to incorrect type",
	1167	ctx.objErrStage1("function call assigned to incorrect type",
1147	1168	\\export fn entry() void {
1148	1169	\\ var arr: [4]f32 = undefined;
1149	1170	\\ arr = concat();
...	...	@@ -1155,7 +1176,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1155	1176	"tmp.zig:3:17: error: expected type '[4]f32', found '[16]f32'",
1156	1177	});
1157	1178
1158		cases.add("generic function call assigned to incorrect type",
	1179	ctx.objErrStage1("generic function call assigned to incorrect type",
1159	1180	\\pub export fn entry() void {
1160	1181	\\ var res: []i32 = undefined;
1161	1182	\\ res = myAlloc(i32);
...	...	@@ -1167,12 +1188,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1167	1188	"tmp.zig:3:18: error: expected type '[]i32', found 'anyerror!i32",
1168	1189	});
1169	1190
1170		cases.addTest("non-exhaustive enums",
	1191	ctx.testErrStage1("non-exhaustive enum marker assigned a value",
1171	1192	\\const A = enum {
1172	1193	\\ a,
1173	1194	\\ b,
1174	1195	\\ _ = 1,
1175	1196	\\};
	1197	\\const B = enum {
	1198	\\ a,
	1199	\\ b,
	1200	\\ _,
	1201	\\};
	1202	\\comptime { _ = A; _ = B; }
	1203	, &[_][]const u8{
	1204	"tmp.zig:4:9: error: '_' is used to mark an enum as non-exhaustive and cannot be assigned a value",
	1205	"tmp.zig:6:11: error: non-exhaustive enum missing integer tag type",
	1206	"tmp.zig:9:5: note: marked non-exhaustive here",
	1207	});
	1208
	1209	ctx.testErrStage1("non-exhaustive enums",
1176	1210	\\const B = enum(u1) {
1177	1211	\\ a,
1178	1212	\\ _,
...	...	@@ -1184,18 +1218,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1184	1218	\\ _,
1185	1219	\\};
1186	1220	\\pub export fn entry() void {
1187		\\ _ = A;
1188	1221	\\ _ = B;
1189	1222	\\ _ = C;
1190	1223	\\}
1191	1224	, &[_][]const u8{
1192		"tmp.zig:4:5: error: value assigned to '_' field of non-exhaustive enum",
1193		"error: non-exhaustive enum must specify size",
1194		"error: non-exhaustive enum specifies every value",
1195		"error: '_' field of non-exhaustive enum must be last",
	1225	"tmp.zig:3:5: error: '_' field of non-exhaustive enum must be last",
	1226	"tmp.zig:6:11: error: non-exhaustive enum specifies every value",
1196	1227	});
1197	1228
1198		cases.addTest("switching with non-exhaustive enums",
	1229	ctx.testErrStage1("switching with non-exhaustive enums",
1199	1230	\\const E = enum(u8) {
1200	1231	\\ a,
1201	1232	\\ b,
...	...	@@ -1228,7 +1259,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1228	1259	"tmp.zig:21:5: error: `_` prong not allowed when switching on tagged union",
1229	1260	});
1230	1261
1231		cases.add("switch expression - unreachable else prong (bool)",
	1262	ctx.objErrStage1("switch expression - unreachable else prong (bool)",
1232	1263	\\fn foo(x: bool) void {
1233	1264	\\ switch (x) {
1234	1265	\\ true => {},
...	...	@@ -1241,7 +1272,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1241	1272	"tmp.zig:5:9: error: unreachable else prong, all cases already handled",
1242	1273	});
1243	1274
1244		cases.add("switch expression - unreachable else prong (u1)",
	1275	ctx.objErrStage1("switch expression - unreachable else prong (u1)",
1245	1276	\\fn foo(x: u1) void {
1246	1277	\\ switch (x) {
1247	1278	\\ 0 => {},
...	...	@@ -1254,7 +1285,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1254	1285	"tmp.zig:5:9: error: unreachable else prong, all cases already handled",
1255	1286	});
1256	1287
1257		cases.add("switch expression - unreachable else prong (u2)",
	1288	ctx.objErrStage1("switch expression - unreachable else prong (u2)",
1258	1289	\\fn foo(x: u2) void {
1259	1290	\\ switch (x) {
1260	1291	\\ 0 => {},
...	...	@@ -1269,7 +1300,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1269	1300	"tmp.zig:7:9: error: unreachable else prong, all cases already handled",
1270	1301	});
1271	1302
1272		cases.add("switch expression - unreachable else prong (range u8)",
	1303	ctx.objErrStage1("switch expression - unreachable else prong (range u8)",
1273	1304	\\fn foo(x: u8) void {
1274	1305	\\ switch (x) {
1275	1306	\\ 0 => {},
...	...	@@ -1285,7 +1316,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1285	1316	"tmp.zig:8:9: error: unreachable else prong, all cases already handled",
1286	1317	});
1287	1318
1288		cases.add("switch expression - unreachable else prong (range i8)",
	1319	ctx.objErrStage1("switch expression - unreachable else prong (range i8)",
1289	1320	\\fn foo(x: i8) void {
1290	1321	\\ switch (x) {
1291	1322	\\ -128...0 => {},
...	...	@@ -1301,7 +1332,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1301	1332	"tmp.zig:8:9: error: unreachable else prong, all cases already handled",
1302	1333	});
1303	1334
1304		cases.add("switch expression - unreachable else prong (enum)",
	1335	ctx.objErrStage1("switch expression - unreachable else prong (enum)",
1305	1336	\\const TestEnum = enum{ T1, T2 };
1306	1337	\\
1307	1338	\\fn err(x: u8) TestEnum {
...	...	@@ -1324,7 +1355,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1324	1355	"tmp.zig:14:9: error: unreachable else prong, all cases already handled",
1325	1356	});
1326	1357
1327		cases.addTest("@export with empty name string",
	1358	ctx.testErrStage1("@export with empty name string",
1328	1359	\\pub export fn entry() void { }
1329	1360	\\comptime {
1330	1361	\\ @export(entry, .{ .name = "" });
...	...	@@ -1333,7 +1364,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1333	1364	"tmp.zig:3:5: error: exported symbol name cannot be empty",
1334	1365	});
1335	1366
1336		cases.addTest("switch ranges endpoints are validated",
	1367	ctx.testErrStage1("switch ranges endpoints are validated",
1337	1368	\\pub export fn entry() void {
1338	1369	\\ var x: i32 = 0;
1339	1370	\\ switch (x) {
...	...	@@ -1347,16 +1378,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1347	1378	"tmp.zig:5:9: error: range start value is greater than the end value",
1348	1379	});
1349	1380
1350		cases.addTest("errors in for loop bodies are propagated",
	1381	ctx.testErrStage1("errors in for loop bodies are propagated",
1351	1382	\\pub export fn entry() void {
1352	1383	\\ var arr: [100]u8 = undefined;
1353	1384	\\ for (arr) \|bits\| _ = @popCount(bits);
1354	1385	\\}
1355	1386	, &[_][]const u8{
1356		"tmp.zig:3:26: error: expected 2 argument(s), found 1",
	1387	"tmp.zig:3:26: error: expected 2 arguments, found 1",
1357	1388	});
1358	1389
1359		cases.addTest("@call rejects non comptime-known fn - always_inline",
	1390	ctx.testErrStage1("@call rejects non comptime-known fn - always_inline",
1360	1391	\\pub export fn entry() void {
1361	1392	\\ var call_me: fn () void = undefined;
1362	1393	\\ @call(.{ .modifier = .always_inline }, call_me, .{});
...	...	@@ -1365,7 +1396,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1365	1396	"tmp.zig:3:5: error: the specified modifier requires a comptime-known function",
1366	1397	});
1367	1398
1368		cases.addTest("@call rejects non comptime-known fn - compile_time",
	1399	ctx.testErrStage1("@call rejects non comptime-known fn - compile_time",
1369	1400	\\pub export fn entry() void {
1370	1401	\\ var call_me: fn () void = undefined;
1371	1402	\\ @call(.{ .modifier = .compile_time }, call_me, .{});
...	...	@@ -1374,19 +1405,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1374	1405	"tmp.zig:3:5: error: the specified modifier requires a comptime-known function",
1375	1406	});
1376	1407
1377		cases.addTest("error in struct initializer doesn't crash the compiler",
	1408	ctx.testErrStage1("error in struct initializer doesn't crash the compiler",
1378	1409	\\pub export fn entry() void {
1379	1410	\\ const bitfield = struct {
1380	1411	\\ e: u8,
1381	1412	\\ e: u8,
1382	1413	\\ };
1383	1414	\\ var a = .{@sizeOf(bitfield)};
	1415	\\ _ = a;
1384	1416	\\}
1385	1417	, &[_][]const u8{
1386	1418	"tmp.zig:4:9: error: duplicate struct field: 'e'",
1387	1419	});
1388	1420
1389		cases.addTest("repeated invalid field access to generic function returning type crashes compiler. #2655",
	1421	ctx.testErrStage1("repeated invalid field access to generic function returning type crashes compiler. #2655",
1390	1422	\\pub fn A() type {
1391	1423	\\ return Q;
1392	1424	\\}
...	...	@@ -1398,15 +1430,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1398	1430	"tmp.zig:2:12: error: use of undeclared identifier 'Q'",
1399	1431	});
1400	1432
1401		cases.add("bitCast to enum type",
	1433	ctx.objErrStage1("bitCast to enum type",
1402	1434	\\export fn entry() void {
1403	1435	\\ const y = @bitCast(enum(u32) { a, b }, @as(u32, 3));
	1436	\\ _ = y;
1404	1437	\\}
1405	1438	, &[_][]const u8{
1406	1439	"tmp.zig:2:24: error: cannot cast a value of type 'y'",
1407	1440	});
1408	1441
1409		cases.add("comparing against undefined produces undefined value",
	1442	ctx.objErrStage1("comparing against undefined produces undefined value",
1410	1443	\\export fn entry() void {
1411	1444	\\ if (2 == undefined) {}
1412	1445	\\}
...	...	@@ -1414,17 +1447,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1414	1447	"tmp.zig:2:11: error: use of undefined value here causes undefined behavior",
1415	1448	});
1416	1449
1417		cases.add("comptime ptrcast of zero-sized type",
	1450	ctx.objErrStage1("comptime ptrcast of zero-sized type",
1418	1451	\\fn foo() void {
1419	1452	\\ const node: struct {} = undefined;
1420	1453	\\ const vla_ptr = @ptrCast([*]const u8, &node);
	1454	\\ _ = vla_ptr;
1421	1455	\\}
1422	1456	\\comptime { foo(); }
1423	1457	, &[_][]const u8{
1424	1458	"tmp.zig:3:21: error: 'const struct:2:17' and '[]const u8' do not have the same in-memory representation",
1425	1459	});
1426	1460
1427		cases.add("slice sentinel mismatch",
	1461	ctx.objErrStage1("slice sentinel mismatch",
1428	1462	\\fn foo() [:0]u8 {
1429	1463	\\ var x: []u8 = undefined;
1430	1464	\\ return x;
...	...	@@ -1435,7 +1469,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1435	1469	"tmp.zig:3:12: note: destination pointer requires a terminating '0' sentinel",
1436	1470	});
1437	1471
1438		cases.add("cmpxchg with float",
	1472	ctx.objErrStage1("cmpxchg with float",
1439	1473	\\export fn entry() void {
1440	1474	\\ var x: f32 = 0;
1441	1475	\\ _ = @cmpxchgWeak(f32, &x, 1, 2, .SeqCst, .SeqCst);
...	...	@@ -1444,7 +1478,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1444	1478	"tmp.zig:3:22: error: expected bool, integer, enum or pointer type, found 'f32'",
1445	1479	});
1446	1480
1447		cases.add("atomicrmw with float op not .Xchg, .Add or .Sub",
	1481	ctx.objErrStage1("atomicrmw with float op not .Xchg, .Add or .Sub",
1448	1482	\\export fn entry() void {
1449	1483	\\ var x: f32 = 0;
1450	1484	\\ _ = @atomicRmw(f32, &x, .And, 2, .SeqCst);
...	...	@@ -1453,15 +1487,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1453	1487	"tmp.zig:3:29: error: @atomicRmw with float only allowed with .Xchg, .Add and .Sub",
1454	1488	});
1455	1489
1456		cases.add("intToPtr with misaligned address",
	1490	ctx.objErrStage1("intToPtr with misaligned address",
1457	1491	\\pub fn main() void {
1458	1492	\\ var y = @intToPtr([*]align(4) u8, 5);
	1493	\\ _ = y;
1459	1494	\\}
1460	1495	, &[_][]const u8{
1461	1496	"tmp.zig:2:13: error: pointer type '[*]align(4) u8' requires aligned address",
1462	1497	});
1463	1498
1464		cases.add("invalid float literal",
	1499	ctx.objErrStage1("invalid float literal",
1465	1500	\\const std = @import("std");
1466	1501	\\
1467	1502	\\pub fn main() void {
...	...	@@ -1473,170 +1508,209 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1473	1508	"tmp.zig:5:29: error: invalid token: '.'",
1474	1509	});
1475	1510
1476		cases.add("invalid exponent in float literal - 1",
	1511	ctx.objErrStage1("invalid exponent in float literal - 1",
1477	1512	\\fn main() void {
1478	1513	\\ var bad: f128 = 0x1.0p1ab1;
	1514	\\ _ = bad;
1479	1515	\\}
1480	1516	, &[_][]const u8{
1481		"tmp.zig:2:28: error: invalid character: 'a'",
	1517	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1518	"tmp.zig:2:28: note: invalid byte: 'a'",
1482	1519	});
1483	1520
1484		cases.add("invalid exponent in float literal - 2",
	1521	ctx.objErrStage1("invalid exponent in float literal - 2",
1485	1522	\\fn main() void {
1486	1523	\\ var bad: f128 = 0x1.0p50F;
	1524	\\ _ = bad;
1487	1525	\\}
1488	1526	, &[_][]const u8{
1489		"tmp.zig:2:29: error: invalid character: 'F'",
	1527	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1528	"tmp.zig:2:29: note: invalid byte: 'F'",
1490	1529	});
1491	1530
1492		cases.add("invalid underscore placement in float literal - 1",
	1531	ctx.objErrStage1("invalid underscore placement in float literal - 1",
1493	1532	\\fn main() void {
1494	1533	\\ var bad: f128 = 0._0;
	1534	\\ _ = bad;
1495	1535	\\}
1496	1536	, &[_][]const u8{
1497		"tmp.zig:2:23: error: invalid character: '_'",
	1537	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1538	"tmp.zig:2:23: note: invalid byte: '_'",
1498	1539	});
1499	1540
1500		cases.add("invalid underscore placement in float literal - 2",
	1541	ctx.objErrStage1("invalid underscore placement in float literal - 2",
1501	1542	\\fn main() void {
1502	1543	\\ var bad: f128 = 0_.0;
	1544	\\ _ = bad;
1503	1545	\\}
1504	1546	, &[_][]const u8{
1505		"tmp.zig:2:23: error: invalid character: '.'",
	1547	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1548	"tmp.zig:2:23: note: invalid byte: '.'",
1506	1549	});
1507	1550
1508		cases.add("invalid underscore placement in float literal - 3",
	1551	ctx.objErrStage1("invalid underscore placement in float literal - 3",
1509	1552	\\fn main() void {
1510	1553	\\ var bad: f128 = 0.0_;
	1554	\\ _ = bad;
1511	1555	\\}
1512	1556	, &[_][]const u8{
1513		"tmp.zig:2:25: error: invalid character: ';'",
	1557	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1558	"tmp.zig:2:25: note: invalid byte: ';'",
1514	1559	});
1515	1560
1516		cases.add("invalid underscore placement in float literal - 4",
	1561	ctx.objErrStage1("invalid underscore placement in float literal - 4",
1517	1562	\\fn main() void {
1518	1563	\\ var bad: f128 = 1.0e_1;
	1564	\\ _ = bad;
1519	1565	\\}
1520	1566	, &[_][]const u8{
1521		"tmp.zig:2:25: error: invalid character: '_'",
	1567	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1568	"tmp.zig:2:25: note: invalid byte: '_'",
1522	1569	});
1523	1570
1524		cases.add("invalid underscore placement in float literal - 5",
	1571	ctx.objErrStage1("invalid underscore placement in float literal - 5",
1525	1572	\\fn main() void {
1526	1573	\\ var bad: f128 = 1.0e+_1;
	1574	\\ _ = bad;
1527	1575	\\}
1528	1576	, &[_][]const u8{
1529		"tmp.zig:2:26: error: invalid character: '_'",
	1577	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1578	"tmp.zig:2:26: note: invalid byte: '_'",
1530	1579	});
1531	1580
1532		cases.add("invalid underscore placement in float literal - 6",
	1581	ctx.objErrStage1("invalid underscore placement in float literal - 6",
1533	1582	\\fn main() void {
1534	1583	\\ var bad: f128 = 1.0e-_1;
	1584	\\ _ = bad;
1535	1585	\\}
1536	1586	, &[_][]const u8{
1537		"tmp.zig:2:26: error: invalid character: '_'",
	1587	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1588	"tmp.zig:2:26: note: invalid byte: '_'",
1538	1589	});
1539	1590
1540		cases.add("invalid underscore placement in float literal - 7",
	1591	ctx.objErrStage1("invalid underscore placement in float literal - 7",
1541	1592	\\fn main() void {
1542	1593	\\ var bad: f128 = 1.0e-1_;
	1594	\\ _ = bad;
1543	1595	\\}
1544	1596	, &[_][]const u8{
1545		"tmp.zig:2:28: error: invalid character: ';'",
	1597	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1598	"tmp.zig:2:28: note: invalid byte: ';'",
1546	1599	});
1547	1600
1548		cases.add("invalid underscore placement in float literal - 9",
	1601	ctx.objErrStage1("invalid underscore placement in float literal - 9",
1549	1602	\\fn main() void {
1550	1603	\\ var bad: f128 = 1__0.0e-1;
	1604	\\ _ = bad;
1551	1605	\\}
1552	1606	, &[_][]const u8{
1553		"tmp.zig:2:23: error: invalid character: '_'",
	1607	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1608	"tmp.zig:2:23: note: invalid byte: '_'",
1554	1609	});
1555	1610
1556		cases.add("invalid underscore placement in float literal - 10",
	1611	ctx.objErrStage1("invalid underscore placement in float literal - 10",
1557	1612	\\fn main() void {
1558	1613	\\ var bad: f128 = 1.0__0e-1;
	1614	\\ _ = bad;
1559	1615	\\}
1560	1616	, &[_][]const u8{
1561		"tmp.zig:2:25: error: invalid character: '_'",
	1617	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1618	"tmp.zig:2:25: note: invalid byte: '_'",
1562	1619	});
1563	1620
1564		cases.add("invalid underscore placement in float literal - 11",
	1621	ctx.objErrStage1("invalid underscore placement in float literal - 11",
1565	1622	\\fn main() void {
1566	1623	\\ var bad: f128 = 1.0e-1__0;
	1624	\\ _ = bad;
1567	1625	\\}
1568	1626	, &[_][]const u8{
1569		"tmp.zig:2:28: error: invalid character: '_'",
	1627	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1628	"tmp.zig:2:28: note: invalid byte: '_'",
1570	1629	});
1571	1630
1572		cases.add("invalid underscore placement in float literal - 12",
	1631	ctx.objErrStage1("invalid underscore placement in float literal - 12",
1573	1632	\\fn main() void {
1574	1633	\\ var bad: f128 = 0_x0.0;
	1634	\\ _ = bad;
1575	1635	\\}
1576	1636	, &[_][]const u8{
1577		"tmp.zig:2:23: error: invalid character: 'x'",
	1637	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1638	"tmp.zig:2:23: note: invalid byte: 'x'",
1578	1639	});
1579	1640
1580		cases.add("invalid underscore placement in float literal - 13",
	1641	ctx.objErrStage1("invalid underscore placement in float literal - 13",
1581	1642	\\fn main() void {
1582	1643	\\ var bad: f128 = 0x_0.0;
	1644	\\ _ = bad;
1583	1645	\\}
1584	1646	, &[_][]const u8{
1585		"tmp.zig:2:23: error: invalid character: '_'",
	1647	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1648	"tmp.zig:2:23: note: invalid byte: '_'",
1586	1649	});
1587	1650
1588		cases.add("invalid underscore placement in float literal - 14",
	1651	ctx.objErrStage1("invalid underscore placement in float literal - 14",
1589	1652	\\fn main() void {
1590	1653	\\ var bad: f128 = 0x0.0_p1;
	1654	\\ _ = bad;
1591	1655	\\}
1592	1656	, &[_][]const u8{
1593		"tmp.zig:2:27: error: invalid character: 'p'",
	1657	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1658	"tmp.zig:2:27: note: invalid byte: 'p'",
1594	1659	});
1595	1660
1596		cases.add("invalid underscore placement in int literal - 1",
	1661	ctx.objErrStage1("invalid underscore placement in int literal - 1",
1597	1662	\\fn main() void {
1598	1663	\\ var bad: u128 = 0010_;
	1664	\\ _ = bad;
1599	1665	\\}
1600	1666	, &[_][]const u8{
1601		"tmp.zig:2:26: error: invalid character: ';'",
	1667	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1668	"tmp.zig:2:26: note: invalid byte: ';'",
1602	1669	});
1603	1670
1604		cases.add("invalid underscore placement in int literal - 2",
	1671	ctx.objErrStage1("invalid underscore placement in int literal - 2",
1605	1672	\\fn main() void {
1606	1673	\\ var bad: u128 = 0b0010_;
	1674	\\ _ = bad;
1607	1675	\\}
1608	1676	, &[_][]const u8{
1609		"tmp.zig:2:28: error: invalid character: ';'",
	1677	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1678	"tmp.zig:2:28: note: invalid byte: ';'",
1610	1679	});
1611	1680
1612		cases.add("invalid underscore placement in int literal - 3",
	1681	ctx.objErrStage1("invalid underscore placement in int literal - 3",
1613	1682	\\fn main() void {
1614	1683	\\ var bad: u128 = 0o0010_;
	1684	\\ _ = bad;
1615	1685	\\}
1616	1686	, &[_][]const u8{
1617		"tmp.zig:2:28: error: invalid character: ';'",
	1687	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1688	"tmp.zig:2:28: note: invalid byte: ';'",
1618	1689	});
1619	1690
1620		cases.add("invalid underscore placement in int literal - 4",
	1691	ctx.objErrStage1("invalid underscore placement in int literal - 4",
1621	1692	\\fn main() void {
1622	1693	\\ var bad: u128 = 0x0010_;
	1694	\\ _ = bad;
1623	1695	\\}
1624	1696	, &[_][]const u8{
1625		"tmp.zig:2:28: error: invalid character: ';'",
	1697	"tmp.zig:2:21: error: expected expression, found 'invalid'",
	1698	"tmp.zig:2:28: note: invalid byte: ';'",
1626	1699	});
1627	1700
1628		cases.add("comptime struct field, no init value",
	1701	ctx.objErrStage1("comptime struct field, no init value",
1629	1702	\\const Foo = struct {
1630	1703	\\ comptime b: i32,
1631	1704	\\};
1632	1705	\\export fn entry() void {
1633	1706	\\ var f: Foo = undefined;
	1707	\\ _ = f;
1634	1708	\\}
1635	1709	, &[_][]const u8{
1636		"tmp.zig:2:5: error: comptime struct field missing initialization value",
	1710	"tmp.zig:2:5: error: comptime field without default initialization value",
1637	1711	});
1638	1712
1639		cases.add("bad usage of @call",
	1713	ctx.objErrStage1("bad usage of @call",
1640	1714	\\export fn entry1() void {
1641	1715	\\ @call(.{}, foo, {});
1642	1716	\\}
...	...	@@ -1665,20 +1739,26 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1665	1739	"tmp.zig:15:5: error: the specified modifier requires a comptime-known function",
1666	1740	});
1667	1741
1668		cases.add("exported async function",
	1742	ctx.objErrStage1("exported async function",
1669	1743	\\export fn foo() callconv(.Async) void {}
1670	1744	, &[_][]const u8{
1671	1745	"tmp.zig:1:1: error: exported function cannot be async",
1672	1746	});
1673	1747
1674		cases.addExe("main missing name",
	1748	ctx.exeErrStage1("main missing name",
1675	1749	\\pub fn (main) void {}
1676	1750	, &[_][]const u8{
1677	1751	"tmp.zig:1:5: error: missing function name",
1678	1752	});
1679	1753
1680		cases.addCase(x: {
1681		var tc = cases.create("call with new stack on unsupported target",
	1754	{
	1755	const case = ctx.obj("call with new stack on unsupported target", .{
	1756	.cpu_arch = .wasm32,
	1757	.os_tag = .wasi,
	1758	.abi = .none,
	1759	});
	1760	case.backend = .stage1;
	1761	case.addError(
1682	1762	\\var buf: [10]u8 align(16) = undefined;
1683	1763	\\export fn entry() void {
1684	1764	\\ @call(.{.stack = &buf}, foo, .{});
...	...	@@ -1687,17 +1767,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1687	1767	, &[_][]const u8{
1688	1768	"tmp.zig:3:5: error: target arch 'wasm32' does not support calling with a new stack",
1689	1769	});
1690		tc.target = std.zig.CrossTarget{
1691		.cpu_arch = .wasm32,
1692		.os_tag = .wasi,
1693		.abi = .none,
1694		};
1695		break :x tc;
1696		});
	1770	}
1697	1771
1698	1772	// Note: One of the error messages here is backwards. It would be nice to fix, but that's not
1699	1773	// going to stop me from merging this branch which fixes a bunch of other stuff.
1700		cases.add("incompatible sentinels",
	1774	ctx.objErrStage1("incompatible sentinels",
1701	1775	\\export fn entry1(ptr: [:255]u8) [:0]u8 {
1702	1776	\\ return ptr;
1703	1777	\\}
...	...	@@ -1706,9 +1780,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1706	1780	\\}
1707	1781	\\export fn entry3() void {
1708	1782	\\ var array: [2:0]u8 = [_:255]u8{1, 2};
	1783	\\ _ = array;
1709	1784	\\}
1710	1785	\\export fn entry4() void {
1711	1786	\\ var array: [2:0]u8 = [_]u8{1, 2};
	1787	\\ _ = array;
1712	1788	\\}
1713	1789	, &[_][]const u8{
1714	1790	"tmp.zig:2:12: error: expected type '[:0]u8', found '[:255]u8'",
...	...	@@ -1718,11 +1794,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1718	1794
1719	1795	"tmp.zig:8:35: error: expected type '[2:255]u8', found '[2:0]u8'",
1720	1796	"tmp.zig:8:35: note: destination array requires a terminating '255' sentinel, but source array has a terminating '0' sentinel",
1721		"tmp.zig:11:31: error: expected type '[2:0]u8', found '[2]u8'",
1722		"tmp.zig:11:31: note: destination array requires a terminating '0' sentinel",
	1797	"tmp.zig:12:31: error: expected type '[2:0]u8', found '[2]u8'",
	1798	"tmp.zig:12:31: note: destination array requires a terminating '0' sentinel",
1723	1799	});
1724	1800
1725		cases.add("empty switch on an integer",
	1801	ctx.objErrStage1("empty switch on an integer",
1726	1802	\\export fn entry() void {
1727	1803	\\ var x: u32 = 0;
1728	1804	\\ switch(x) {}
...	...	@@ -1731,7 +1807,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1731	1807	"tmp.zig:3:5: error: switch must handle all possibilities",
1732	1808	});
1733	1809
1734		cases.add("incorrect return type",
	1810	ctx.objErrStage1("incorrect return type",
1735	1811	\\ pub export fn entry() void{
1736	1812	\\ _ = foo();
1737	1813	\\ }
...	...	@@ -1751,12 +1827,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1751	1827	"tmp.zig:8:16: error: expected type 'A', found 'B'",
1752	1828	});
1753	1829
1754		cases.add("regression test #2980: base type u32 is not type checked properly when assigning a value within a struct",
	1830	ctx.objErrStage1("regression test #2980: base type u32 is not type checked properly when assigning a value within a struct",
1755	1831	\\const Foo = struct {
1756	1832	\\ ptr: ?*usize,
1757	1833	\\ uval: u32,
1758	1834	\\};
1759	1835	\\fn get_uval(x: u32) !u32 {
	1836	\\ _ = x;
1760	1837	\\ return error.NotFound;
1761	1838	\\}
1762	1839	\\export fn entry() void {
...	...	@@ -1764,12 +1841,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1764	1841	\\ .ptr = null,
1765	1842	\\ .uval = get_uval(42),
1766	1843	\\ };
	1844	\\ _ = afoo;
1767	1845	\\}
1768	1846	, &[_][]const u8{
1769		"tmp.zig:11:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'",
	1847	"tmp.zig:12:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'",
1770	1848	});
1771	1849
1772		cases.add("assigning to struct or union fields that are not optionals with a function that returns an optional",
	1850	ctx.objErrStage1("assigning to struct or union fields that are not optionals with a function that returns an optional",
1773	1851	\\fn maybe(is: bool) ?u8 {
1774	1852	\\ if (is) return @as(u8, 10) else return null;
1775	1853	\\}
...	...	@@ -1782,12 +1860,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1782	1860	\\export fn entry() void {
1783	1861	\\ var u = U{ .Ye = maybe(false) };
1784	1862	\\ var s = S{ .num = maybe(false) };
	1863	\\ _ = u;
	1864	\\ _ = s;
1785	1865	\\}
1786	1866	, &[_][]const u8{
1787	1867	"tmp.zig:11:27: error: expected type 'u8', found '?u8'",
1788	1868	});
1789	1869
1790		cases.add("missing result type for phi node",
	1870	ctx.objErrStage1("missing result type for phi node",
1791	1871	\\fn foo() !void {
1792	1872	\\ return anyerror.Foo;
1793	1873	\\}
...	...	@@ -1798,7 +1878,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1798	1878	"tmp.zig:5:17: error: integer value 0 cannot be coerced to type 'void'",
1799	1879	});
1800	1880
1801		cases.add("atomicrmw with enum op not .Xchg",
	1881	ctx.objErrStage1("atomicrmw with enum op not .Xchg",
1802	1882	\\export fn entry() void {
1803	1883	\\ const E = enum(u8) {
1804	1884	\\ a,
...	...	@@ -1813,7 +1893,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1813	1893	"tmp.zig:9:27: error: @atomicRmw with enum only allowed with .Xchg",
1814	1894	});
1815	1895
1816		cases.add("disallow coercion from non-null-terminated pointer to null-terminated pointer",
	1896	ctx.objErrStage1("disallow coercion from non-null-terminated pointer to null-terminated pointer",
1817	1897	\\extern fn puts(s: [*:0]const u8) c_int;
1818	1898	\\pub fn main() void {
1819	1899	\\ const no_zero_array = [_]u8{'h', 'e', 'l', 'l', 'o'};
...	...	@@ -1824,7 +1904,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1824	1904	"tmp.zig:5:14: error: expected type '[:0]const u8', found '[]const u8'",
1825	1905	});
1826	1906
1827		cases.add("atomic orderings of atomicStore Acquire or AcqRel",
	1907	ctx.objErrStage1("atomic orderings of atomicStore Acquire or AcqRel",
1828	1908	\\export fn entry() void {
1829	1909	\\ var x: u32 = 0;
1830	1910	\\ @atomicStore(u32, &x, 1, .Acquire);
...	...	@@ -1833,7 +1913,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1833	1913	"tmp.zig:3:30: error: @atomicStore atomic ordering must not be Acquire or AcqRel",
1834	1914	});
1835	1915
1836		cases.add("missing const in slice with nested array type",
	1916	ctx.objErrStage1("missing const in slice with nested array type",
1837	1917	\\const Geo3DTex2D = struct { vertices: [][2]f32 };
1838	1918	\\pub fn getGeo3DTex2D() Geo3DTex2D {
1839	1919	\\ return Geo3DTex2D{
...	...	@@ -1844,12 +1924,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1844	1924	\\}
1845	1925	\\export fn entry() void {
1846	1926	\\ var geo_data = getGeo3DTex2D();
	1927	\\ _ = geo_data;
1847	1928	\\}
1848	1929	, &[_][]const u8{
1849	1930	"tmp.zig:4:30: error: array literal requires address-of operator to coerce to slice type '[][2]f32'",
1850	1931	});
1851	1932
1852		cases.add("slicing of global undefined pointer",
	1933	ctx.objErrStage1("slicing of global undefined pointer",
1853	1934	\\var buf: *[1]u8 = undefined;
1854	1935	\\export fn entry() void {
1855	1936	\\ _ = buf[0..1];
...	...	@@ -1858,18 +1939,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1858	1939	"tmp.zig:3:12: error: non-zero length slice of undefined pointer",
1859	1940	});
1860	1941
1861		cases.add("using invalid types in function call raises an error",
	1942	ctx.objErrStage1("using invalid types in function call raises an error",
1862	1943	\\const MenuEffect = enum {};
1863		\\fn func(effect: MenuEffect) void {}
	1944	\\fn func(effect: MenuEffect) void { _ = effect; }
1864	1945	\\export fn entry() void {
1865	1946	\\ func(MenuEffect.ThisDoesNotExist);
1866	1947	\\}
1867	1948	, &[_][]const u8{
1868		"tmp.zig:1:20: error: enums must have 1 or more fields",
1869		"tmp.zig:4:20: note: referenced here",
	1949	"tmp.zig:1:20: error: enum declarations must have at least one tag",
1870	1950	});
1871	1951
1872		cases.add("store vector pointer with unknown runtime index",
	1952	ctx.objErrStage1("store vector pointer with unknown runtime index",
1873	1953	\\export fn entry() void {
1874	1954	\\ var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
1875	1955	\\
...	...	@@ -1884,22 +1964,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1884	1964	"tmp.zig:9:8: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
1885	1965	});
1886	1966
1887		cases.add("load vector pointer with unknown runtime index",
	1967	ctx.objErrStage1("load vector pointer with unknown runtime index",
1888	1968	\\export fn entry() void {
1889	1969	\\ var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
1890	1970	\\
1891	1971	\\ var i: u32 = 0;
1892	1972	\\ var x = loadv(&v[i]);
	1973	\\ _ = x;
1893	1974	\\}
1894	1975	\\
1895	1976	\\fn loadv(ptr: anytype) i32 {
1896	1977	\\ return ptr.*;
1897	1978	\\}
1898	1979	, &[_][]const u8{
1899		"tmp.zig:9:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
	1980	"tmp.zig:10:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
1900	1981	});
1901	1982
1902		cases.add("using an unknown len ptr type instead of array",
	1983	ctx.objErrStage1("using an unknown len ptr type instead of array",
1903	1984	\\const resolutions = [][]const u8{
1904	1985	\\ "[320 240 ]",
1905	1986	\\ null,
...	...	@@ -1911,7 +1992,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1911	1992	"tmp.zig:1:21: error: expected array type or [_], found '[][]const u8'",
1912	1993	});
1913	1994
1914		cases.add("comparison with error union and error value",
	1995	ctx.objErrStage1("comparison with error union and error value",
1915	1996	\\export fn entry() void {
1916	1997	\\ var number_or_error: anyerror!i32 = error.SomethingAwful;
1917	1998	\\ _ = number_or_error == error.SomethingAwful;
...	...	@@ -1920,7 +2001,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1920	2001	"tmp.zig:3:25: error: operator not allowed for type 'anyerror!i32'",
1921	2002	});
1922	2003
1923		cases.add("switch with overlapping case ranges",
	2004	ctx.objErrStage1("switch with overlapping case ranges",
1924	2005	\\export fn entry() void {
1925	2006	\\ var q: u8 = 0;
1926	2007	\\ switch (q) {
...	...	@@ -1932,28 +2013,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1932	2013	"tmp.zig:5:9: error: duplicate switch value",
1933	2014	});
1934	2015
1935		cases.add("invalid optional type in extern struct",
	2016	ctx.objErrStage1("invalid optional type in extern struct",
1936	2017	\\const stroo = extern struct {
1937	2018	\\ moo: ?[*c]u8,
1938	2019	\\};
1939		\\export fn testf(fluff: *stroo) void {}
	2020	\\export fn testf(fluff: *stroo) void { _ = fluff; }
1940	2021	, &[_][]const u8{
1941	2022	"tmp.zig:2:5: error: extern structs cannot contain fields of type '?[*c]u8'",
1942	2023	});
1943	2024
1944		cases.add("attempt to negate a non-integer, non-float or non-vector type",
	2025	ctx.objErrStage1("attempt to negate a non-integer, non-float or non-vector type",
1945	2026	\\fn foo() anyerror!u32 {
1946	2027	\\ return 1;
1947	2028	\\}
1948	2029	\\
1949	2030	\\export fn entry() void {
1950	2031	\\ const x = -foo();
	2032	\\ _ = x;
1951	2033	\\}
1952	2034	, &[_][]const u8{
1953	2035	"tmp.zig:6:15: error: negation of type 'anyerror!u32'",
1954	2036	});
1955	2037
1956		cases.add("attempt to create 17 bit float type",
	2038	ctx.objErrStage1("attempt to create 17 bit float type",
1957	2039	\\const builtin = @import("std").builtin;
1958	2040	\\comptime {
1959	2041	\\ _ = @Type(builtin.TypeInfo { .Float = builtin.TypeInfo.Float { .bits = 17 } });
...	...	@@ -1962,7 +2044,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1962	2044	"tmp.zig:3:32: error: 17-bit float unsupported",
1963	2045	});
1964	2046
1965		cases.add("wrong type for @Type",
	2047	ctx.objErrStage1("wrong type for @Type",
1966	2048	\\export fn entry() void {
1967	2049	\\ _ = @Type(0);
1968	2050	\\}
...	...	@@ -1970,7 +2052,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1970	2052	"tmp.zig:2:15: error: expected type 'std.builtin.TypeInfo', found 'comptime_int'",
1971	2053	});
1972	2054
1973		cases.add("@Type with non-constant expression",
	2055	ctx.objErrStage1("@Type with non-constant expression",
1974	2056	\\const builtin = @import("std").builtin;
1975	2057	\\var globalTypeInfo : builtin.TypeInfo = undefined;
1976	2058	\\export fn entry() void {
...	...	@@ -1980,7 +2062,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1980	2062	"tmp.zig:4:15: error: unable to evaluate constant expression",
1981	2063	});
1982	2064
1983		cases.add("wrong type for argument tuple to @asyncCall",
	2065	ctx.objErrStage1("wrong type for argument tuple to @asyncCall",
1984	2066	\\export fn entry1() void {
1985	2067	\\ var frame: @Frame(foo) = undefined;
1986	2068	\\ @asyncCall(&frame, {}, foo, {});
...	...	@@ -1993,7 +2075,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1993	2075	"tmp.zig:3:33: error: expected tuple or struct, found 'void'",
1994	2076	});
1995	2077
1996		cases.add("wrong type for result ptr to @asyncCall",
	2078	ctx.objErrStage1("wrong type for result ptr to @asyncCall",
1997	2079	\\export fn entry() void {
1998	2080	\\ _ = async amain();
1999	2081	\\}
...	...	@@ -2008,25 +2090,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2008	2090	"tmp.zig:6:37: error: expected type '*i32', found 'bool'",
2009	2091	});
2010	2092
2011		cases.add("shift amount has to be an integer type",
	2093	ctx.objErrStage1("shift amount has to be an integer type",
2012	2094	\\export fn entry() void {
2013	2095	\\ const x = 1 << &@as(u8, 10);
	2096	\\ _ = x;
2014	2097	\\}
2015	2098	, &[_][]const u8{
2016	2099	"tmp.zig:2:21: error: shift amount has to be an integer type, but found '*const u8'",
2017	2100	"tmp.zig:2:17: note: referenced here",
2018	2101	});
2019	2102
2020		cases.add("bit shifting only works on integer types",
	2103	ctx.objErrStage1("bit shifting only works on integer types",
2021	2104	\\export fn entry() void {
2022	2105	\\ const x = &@as(u8, 1) << 10;
	2106	\\ _ = x;
2023	2107	\\}
2024	2108	, &[_][]const u8{
2025	2109	"tmp.zig:2:16: error: bit shifting operation expected integer type, found '*const u8'",
2026	2110	"tmp.zig:2:27: note: referenced here",
2027	2111	});
2028	2112
2029		cases.add("struct depends on itself via optional field",
	2113	ctx.objErrStage1("struct depends on itself via optional field",
2030	2114	\\const LhsExpr = struct {
2031	2115	\\ rhsExpr: ?AstObject,
2032	2116	\\};
...	...	@@ -2036,6 +2120,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2036	2120	\\export fn entry() void {
2037	2121	\\ const lhsExpr = LhsExpr{ .rhsExpr = null };
2038	2122	\\ const obj = AstObject{ .lhsExpr = lhsExpr };
	2123	\\ _ = obj;
2039	2124	\\}
2040	2125	, &[_][]const u8{
2041	2126	"tmp.zig:1:17: error: struct 'LhsExpr' depends on itself",
...	...	@@ -2043,51 +2128,54 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2043	2128	"tmp.zig:2:5: note: while checking this field",
2044	2129	});
2045	2130
2046		cases.add("alignment of enum field specified",
	2131	ctx.objErrStage1("alignment of enum field specified",
2047	2132	\\const Number = enum {
2048	2133	\\ a,
2049	2134	\\ b align(i32),
2050	2135	\\};
2051	2136	\\export fn entry1() void {
2052	2137	\\ var x: Number = undefined;
	2138	\\ _ = x;
2053	2139	\\}
2054	2140	, &[_][]const u8{
2055		"tmp.zig:3:13: error: structs and unions, not enums, support field alignment",
2056		"tmp.zig:1:16: note: consider 'union(enum)' here",
	2141	"tmp.zig:3:7: error: expected ',', found 'align'",
2057	2142	});
2058	2143
2059		cases.add("bad alignment type",
	2144	ctx.objErrStage1("bad alignment type",
2060	2145	\\export fn entry1() void {
2061	2146	\\ var x: []align(true) i32 = undefined;
	2147	\\ _ = x;
2062	2148	\\}
2063	2149	\\export fn entry2() void {
2064	2150	\\ var x: *align(@as(f64, 12.34)) i32 = undefined;
	2151	\\ _ = x;
2065	2152	\\}
2066	2153	, &[_][]const u8{
2067	2154	"tmp.zig:2:20: error: expected type 'u29', found 'bool'",
2068		"tmp.zig:5:19: error: fractional component prevents float value 12.340000 from being casted to type 'u29'",
	2155	"tmp.zig:6:19: error: fractional component prevents float value 12.340000 from being casted to type 'u29'",
2069	2156	});
2070	2157
2071		cases.addCase(x: {
2072		var tc = cases.create("variable in inline assembly template cannot be found",
	2158	{
	2159	const case = ctx.obj("variable in inline assembly template cannot be found", .{
	2160	.cpu_arch = .x86_64,
	2161	.os_tag = .linux,
	2162	.abi = .gnu,
	2163	});
	2164	case.backend = .stage1;
	2165	case.addError(
2073	2166	\\export fn entry() void {
2074	2167	\\ var sp = asm volatile (
2075	2168	\\ "mov %[foo], sp"
2076	2169	\\ : [bar] "=r" (-> usize)
2077	2170	\\ );
	2171	\\ _ = sp;
2078	2172	\\}
2079	2173	, &[_][]const u8{
2080	2174	"tmp.zig:2:14: error: could not find 'foo' in the inputs or outputs",
2081	2175	});
2082		tc.target = std.zig.CrossTarget{
2083		.cpu_arch = .x86_64,
2084		.os_tag = .linux,
2085		.abi = .gnu,
2086		};
2087		break :x tc;
2088		});
	2176	}
2089	2177
2090		cases.add("indirect recursion of async functions detected",
	2178	ctx.objErrStage1("indirect recursion of async functions detected",
2091	2179	\\var frame: ?anyframe = null;
2092	2180	\\
2093	2181	\\export fn a() void {
...	...	@@ -2122,7 +2210,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2122	2210	"tmp.zig:26:25: note: when analyzing type '@Frame(rangeSumIndirect)' here",
2123	2211	});
2124	2212
2125		cases.add("non-async function pointer eventually is inferred to become async",
	2213	ctx.objErrStage1("non-async function pointer eventually is inferred to become async",
2126	2214	\\export fn a() void {
2127	2215	\\ var non_async_fn: fn () void = undefined;
2128	2216	\\ non_async_fn = func;
...	...	@@ -2136,20 +2224,26 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2136	2224	"tmp.zig:6:5: note: suspends here",
2137	2225	});
2138	2226
2139		cases.add("bad alignment in @asyncCall",
2140		\\export fn entry() void {
2141		\\ var ptr: fn () callconv(.Async) void = func;
2142		\\ var bytes: [64]u8 = undefined;
2143		\\ _ = @asyncCall(&bytes, {}, ptr, .{});
2144		\\}
2145		\\fn func() callconv(.Async) void {}
2146		, &[_][]const u8{
2147		// Split the check in two as the alignment value is target dependent.
2148		"tmp.zig:4:21: error: expected type '[]align(",
2149		") u8', found '*[64]u8'",
2150		});
	2227	{
	2228	const case = ctx.obj("bad alignment in @asyncCall", .{
	2229	.cpu_arch = .aarch64,
	2230	.os_tag = .linux,
	2231	.abi = .none,
	2232	});
	2233	case.backend = .stage1;
	2234	case.addError(
	2235	\\export fn entry() void {
	2236	\\ var ptr: fn () callconv(.Async) void = func;
	2237	\\ var bytes: [64]u8 = undefined;
	2238	\\ _ = @asyncCall(&bytes, {}, ptr, .{});
	2239	\\}
	2240	\\fn func() callconv(.Async) void {}
	2241	, &[_][]const u8{
	2242	"tmp.zig:4:21: error: expected type '[]align(8) u8', found '*[64]u8'",
	2243	});
	2244	}
2151	2245
2152		cases.add("atomic orderings of fence Acquire or stricter",
	2246	ctx.objErrStage1("atomic orderings of fence Acquire or stricter",
2153	2247	\\export fn entry() void {
2154	2248	\\ @fence(.Monotonic);
2155	2249	\\}
...	...	@@ -2157,20 +2251,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2157	2251	"tmp.zig:2:12: error: atomic ordering must be Acquire or stricter",
2158	2252	});
2159	2253
2160		cases.add("bad alignment in implicit cast from array pointer to slice",
	2254	ctx.objErrStage1("bad alignment in implicit cast from array pointer to slice",
2161	2255	\\export fn a() void {
2162	2256	\\ var x: [10]u8 = undefined;
2163	2257	\\ var y: []align(16) u8 = &x;
	2258	\\ _ = y;
2164	2259	\\}
2165	2260	, &[_][]const u8{
2166	2261	"tmp.zig:3:30: error: expected type '[]align(16) u8', found '*[10]u8'",
2167	2262	});
2168	2263
2169		cases.add("result location incompatibility mismatching handle_is_ptr (generic call)",
	2264	ctx.objErrStage1("result location incompatibility mismatching handle_is_ptr (generic call)",
2170	2265	\\export fn entry() void {
2171	2266	\\ var damn = Container{
2172	2267	\\ .not_optional = getOptional(i32),
2173	2268	\\ };
	2269	\\ _ = damn;
2174	2270	\\}
2175	2271	\\pub fn getOptional(comptime T: type) ?T {
2176	2272	\\ return 0;
...	...	@@ -2182,11 +2278,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2182	2278	"tmp.zig:3:36: error: expected type 'i32', found '?i32'",
2183	2279	});
2184	2280
2185		cases.add("result location incompatibility mismatching handle_is_ptr",
	2281	ctx.objErrStage1("result location incompatibility mismatching handle_is_ptr",
2186	2282	\\export fn entry() void {
2187	2283	\\ var damn = Container{
2188	2284	\\ .not_optional = getOptional(),
2189	2285	\\ };
	2286	\\ _ = damn;
2190	2287	\\}
2191	2288	\\pub fn getOptional() ?i32 {
2192	2289	\\ return 0;
...	...	@@ -2198,7 +2295,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2198	2295	"tmp.zig:3:36: error: expected type 'i32', found '?i32'",
2199	2296	});
2200	2297
2201		cases.add("const frame cast to anyframe",
	2298	ctx.objErrStage1("const frame cast to anyframe",
2202	2299	\\export fn a() void {
2203	2300	\\ const f = async func();
2204	2301	\\ resume f;
...	...	@@ -2206,6 +2303,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2206	2303	\\export fn b() void {
2207	2304	\\ const f = async func();
2208	2305	\\ var x: anyframe = &f;
	2306	\\ _ = x;
2209	2307	\\}
2210	2308	\\fn func() void {
2211	2309	\\ suspend {}
...	...	@@ -2215,27 +2313,30 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2215	2313	"tmp.zig:7:24: error: expected type 'anyframe', found '*const @Frame(func)'",
2216	2314	});
2217	2315
2218		cases.add("prevent bad implicit casting of anyframe types",
	2316	ctx.objErrStage1("prevent bad implicit casting of anyframe types",
2219	2317	\\export fn a() void {
2220	2318	\\ var x: anyframe = undefined;
2221	2319	\\ var y: anyframe->i32 = x;
	2320	\\ _ = y;
2222	2321	\\}
2223	2322	\\export fn b() void {
2224	2323	\\ var x: i32 = undefined;
2225	2324	\\ var y: anyframe->i32 = x;
	2325	\\ _ = y;
2226	2326	\\}
2227	2327	\\export fn c() void {
2228	2328	\\ var x: @Frame(func) = undefined;
2229	2329	\\ var y: anyframe->i32 = &x;
	2330	\\ _ = y;
2230	2331	\\}
2231	2332	\\fn func() void {}
2232	2333	, &[_][]const u8{
2233	2334	"tmp.zig:3:28: error: expected type 'anyframe->i32', found 'anyframe'",
2234		"tmp.zig:7:28: error: expected type 'anyframe->i32', found 'i32'",
2235		"tmp.zig:11:29: error: expected type 'anyframe->i32', found '*@Frame(func)'",
	2335	"tmp.zig:8:28: error: expected type 'anyframe->i32', found 'i32'",
	2336	"tmp.zig:13:29: error: expected type 'anyframe->i32', found '*@Frame(func)'",
2236	2337	});
2237	2338
2238		cases.add("wrong frame type used for async call",
	2339	ctx.objErrStage1("wrong frame type used for async call",
2239	2340	\\export fn entry() void {
2240	2341	\\ var frame: @Frame(foo) = undefined;
2241	2342	\\ frame = async bar();
...	...	@@ -2250,18 +2351,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2250	2351	"tmp.zig:3:13: error: expected type '@Frame(bar)', found '@Frame(foo)'",
2251	2352	});
2252	2353
2253		cases.add("@Frame() of generic function",
	2354	ctx.objErrStage1("@Frame() of generic function",
2254	2355	\\export fn entry() void {
2255	2356	\\ var frame: @Frame(func) = undefined;
	2357	\\ _ = frame;
2256	2358	\\}
2257	2359	\\fn func(comptime T: type) void {
2258	2360	\\ var x: T = undefined;
	2361	\\ _ = x;
2259	2362	\\}
2260	2363	, &[_][]const u8{
2261	2364	"tmp.zig:2:16: error: @Frame() of generic function",
2262	2365	});
2263	2366
2264		cases.add("@frame() causes function to be async",
	2367	ctx.objErrStage1("@frame() causes function to be async",
2265	2368	\\export fn entry() void {
2266	2369	\\ func();
2267	2370	\\}
...	...	@@ -2273,10 +2376,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2273	2376	"tmp.zig:5:9: note: @frame() causes function to be async",
2274	2377	});
2275	2378
2276		cases.add("invalid suspend in exported function",
	2379	ctx.objErrStage1("invalid suspend in exported function",
2277	2380	\\export fn entry() void {
2278	2381	\\ var frame = async func();
2279	2382	\\ var result = await frame;
	2383	\\ _ = result;
2280	2384	\\}
2281	2385	\\fn func() void {
2282	2386	\\ suspend {}
...	...	@@ -2286,7 +2390,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2286	2390	"tmp.zig:3:18: note: await here is a suspend point",
2287	2391	});
2288	2392
2289		cases.add("async function indirectly depends on its own frame",
	2393	ctx.objErrStage1("async function indirectly depends on its own frame",
2290	2394	\\export fn entry() void {
2291	2395	\\ _ = async amain();
2292	2396	\\}
...	...	@@ -2295,6 +2399,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2295	2399	\\}
2296	2400	\\fn other() void {
2297	2401	\\ var x: [@sizeOf(@Frame(amain))]u8 = undefined;
	2402	\\ _ = x;
2298	2403	\\}
2299	2404	, &[_][]const u8{
2300	2405	"tmp.zig:4:1: error: unable to determine async function frame of 'amain'",
...	...	@@ -2302,19 +2407,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2302	2407	"tmp.zig:8:13: note: referenced here",
2303	2408	});
2304	2409
2305		cases.add("async function depends on its own frame",
	2410	ctx.objErrStage1("async function depends on its own frame",
2306	2411	\\export fn entry() void {
2307	2412	\\ _ = async amain();
2308	2413	\\}
2309	2414	\\fn amain() callconv(.Async) void {
2310	2415	\\ var x: [@sizeOf(@Frame(amain))]u8 = undefined;
	2416	\\ _ = x;
2311	2417	\\}
2312	2418	, &[_][]const u8{
2313	2419	"tmp.zig:4:1: error: cannot resolve '@Frame(amain)': function not fully analyzed yet",
2314	2420	"tmp.zig:5:13: note: referenced here",
2315	2421	});
2316	2422
2317		cases.add("non async function pointer passed to @asyncCall",
	2423	ctx.objErrStage1("non async function pointer passed to @asyncCall",
2318	2424	\\export fn entry() void {
2319	2425	\\ var ptr = afunc;
2320	2426	\\ var bytes: [100]u8 align(16) = undefined;
...	...	@@ -2325,7 +2431,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2325	2431	"tmp.zig:4:32: error: expected async function, found 'fn() void'",
2326	2432	});
2327	2433
2328		cases.add("runtime-known async function called",
	2434	ctx.objErrStage1("runtime-known async function called",
2329	2435	\\export fn entry() void {
2330	2436	\\ _ = async amain();
2331	2437	\\}
...	...	@@ -2338,7 +2444,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2338	2444	"tmp.zig:6:12: error: function is not comptime-known; @asyncCall required",
2339	2445	});
2340	2446
2341		cases.add("runtime-known function called with async keyword",
	2447	ctx.objErrStage1("runtime-known function called with async keyword",
2342	2448	\\export fn entry() void {
2343	2449	\\ var ptr = afunc;
2344	2450	\\ _ = async ptr();
...	...	@@ -2349,7 +2455,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2349	2455	"tmp.zig:3:15: error: function is not comptime-known; @asyncCall required",
2350	2456	});
2351	2457
2352		cases.add("function with ccc indirectly calling async function",
	2458	ctx.objErrStage1("function with ccc indirectly calling async function",
2353	2459	\\export fn entry() void {
2354	2460	\\ foo();
2355	2461	\\}
...	...	@@ -2366,7 +2472,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2366	2472	"tmp.zig:8:5: note: suspends here",
2367	2473	});
2368	2474
2369		cases.add("capture group on switch prong with incompatible payload types",
	2475	ctx.objErrStage1("capture group on switch prong with incompatible payload types",
2370	2476	\\const Union = union(enum) {
2371	2477	\\ A: usize,
2372	2478	\\ B: isize,
...	...	@@ -2374,7 +2480,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2374	2480	\\comptime {
2375	2481	\\ var u = Union{ .A = 8 };
2376	2482	\\ switch (u) {
2377		\\ .A, .B => \|e\| unreachable,
	2483	\\ .A, .B => \|e\| {
	2484	\\ _ = e;
	2485	\\ unreachable;
	2486	\\ },
2378	2487	\\ }
2379	2488	\\}
2380	2489	, &[_][]const u8{
...	...	@@ -2383,7 +2492,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2383	2492	"tmp.zig:8:13: note: type 'isize' here",
2384	2493	});
2385	2494
2386		cases.add("wrong type to @hasField",
	2495	ctx.objErrStage1("wrong type to @hasField",
2387	2496	\\export fn entry() bool {
2388	2497	\\ return @hasField(i32, "hi");
2389	2498	\\}
...	...	@@ -2391,44 +2500,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2391	2500	"tmp.zig:2:22: error: type 'i32' does not support @hasField",
2392	2501	});
2393	2502
2394		cases.add("slice passed as array init type with elems",
	2503	ctx.objErrStage1("slice passed as array init type with elems",
2395	2504	\\export fn entry() void {
2396	2505	\\ const x = []u8{1, 2};
	2506	\\ _ = x;
2397	2507	\\}
2398	2508	, &[_][]const u8{
2399	2509	"tmp.zig:2:15: error: array literal requires address-of operator to coerce to slice type '[]u8'",
2400	2510	});
2401	2511
2402		cases.add("slice passed as array init type",
	2512	ctx.objErrStage1("slice passed as array init type",
2403	2513	\\export fn entry() void {
2404	2514	\\ const x = []u8{};
	2515	\\ _ = x;
2405	2516	\\}
2406	2517	, &[_][]const u8{
2407	2518	"tmp.zig:2:15: error: array literal requires address-of operator to coerce to slice type '[]u8'",
2408	2519	});
2409	2520
2410		cases.add("inferred array size invalid here",
	2521	ctx.objErrStage1("inferred array size invalid here",
2411	2522	\\export fn entry() void {
2412	2523	\\ const x = [_]u8;
	2524	\\ _ = x;
2413	2525	\\}
2414	2526	\\export fn entry2() void {
2415	2527	\\ const S = struct { a: *const [_]u8 };
2416	2528	\\ var a = .{ S{} };
	2529	\\ _ = a;
2417	2530	\\}
2418	2531	, &[_][]const u8{
2419		"tmp.zig:2:15: error: inferred array size invalid here",
2420		"tmp.zig:5:34: error: inferred array size invalid here",
	2532	"tmp.zig:2:16: error: unable to infer array size",
	2533	"tmp.zig:6:35: error: unable to infer array size",
2421	2534	});
2422	2535
2423		cases.add("initializing array with struct syntax",
	2536	ctx.objErrStage1("initializing array with struct syntax",
2424	2537	\\export fn entry() void {
2425	2538	\\ const x = [_]u8{ .y = 2 };
	2539	\\ _ = x;
2426	2540	\\}
2427	2541	, &[_][]const u8{
2428	2542	"tmp.zig:2:15: error: initializing array with struct syntax",
2429	2543	});
2430	2544
2431		cases.add("compile error in struct init expression",
	2545	ctx.objErrStage1("compile error in struct init expression",
2432	2546	\\const Foo = struct {
2433	2547	\\ a: i32 = crap,
2434	2548	\\ b: i32,
...	...	@@ -2437,23 +2551,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2437	2551	\\ var x = Foo{
2438	2552	\\ .b = 5,
2439	2553	\\ };
	2554	\\ _ = x;
2440	2555	\\}
2441	2556	, &[_][]const u8{
2442	2557	"tmp.zig:2:14: error: use of undeclared identifier 'crap'",
2443	2558	});
2444	2559
2445		cases.add("undefined as field type is rejected",
	2560	ctx.objErrStage1("undefined as field type is rejected",
2446	2561	\\const Foo = struct {
2447	2562	\\ a: undefined,
2448	2563	\\};
2449	2564	\\export fn entry1() void {
2450	2565	\\ const foo: Foo = undefined;
	2566	\\ _ = foo;
2451	2567	\\}
2452	2568	, &[_][]const u8{
2453	2569	"tmp.zig:2:8: error: use of undefined value here causes undefined behavior",
2454	2570	});
2455	2571
2456		cases.add("@hasDecl with non-container",
	2572	ctx.objErrStage1("@hasDecl with non-container",
2457	2573	\\export fn entry() void {
2458	2574	\\ _ = @hasDecl(i32, "hi");
2459	2575	\\}
...	...	@@ -2461,16 +2577,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2461	2577	"tmp.zig:2:18: error: expected struct, enum, or union; found 'i32'",
2462	2578	});
2463	2579
2464		cases.add("field access of slices",
	2580	ctx.objErrStage1("field access of slices",
2465	2581	\\export fn entry() void {
2466	2582	\\ var slice: []i32 = undefined;
2467	2583	\\ const info = @TypeOf(slice).unknown;
	2584	\\ _ = info;
2468	2585	\\}
2469	2586	, &[_][]const u8{
2470	2587	"tmp.zig:3:32: error: type 'type' does not support field access",
2471	2588	});
2472	2589
2473		cases.add("peer cast then implicit cast const pointer to mutable C pointer",
	2590	ctx.objErrStage1("peer cast then implicit cast const pointer to mutable C pointer",
2474	2591	\\export fn func() void {
2475	2592	\\ var strValue: [*c]u8 = undefined;
2476	2593	\\ strValue = strValue orelse "";
...	...	@@ -2480,19 +2597,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2480	2597	"tmp.zig:3:32: note: cast discards const qualifier",
2481	2598	});
2482	2599
2483		cases.add("overflow in enum value allocation",
	2600	ctx.objErrStage1("overflow in enum value allocation",
2484	2601	\\const Moo = enum(u8) {
2485	2602	\\ Last = 255,
2486	2603	\\ Over,
2487	2604	\\};
2488	2605	\\pub fn main() void {
2489	2606	\\ var y = Moo.Last;
	2607	\\ _ = y;
2490	2608	\\}
2491	2609	, &[_][]const u8{
2492	2610	"tmp.zig:3:5: error: enumeration value 256 too large for type 'u8'",
2493	2611	});
2494	2612
2495		cases.add("attempt to cast enum literal to error",
	2613	ctx.objErrStage1("attempt to cast enum literal to error",
2496	2614	\\export fn entry() void {
2497	2615	\\ switch (error.Hi) {
2498	2616	\\ .Hi => {},
...	...	@@ -2502,7 +2620,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2502	2620	"tmp.zig:3:9: error: expected type 'error{Hi}', found '(enum literal)'",
2503	2621	});
2504	2622
2505		cases.add("@sizeOf bad type",
	2623	ctx.objErrStage1("@sizeOf bad type",
2506	2624	\\export fn entry() usize {
2507	2625	\\ return @sizeOf(@TypeOf(null));
2508	2626	\\}
...	...	@@ -2510,7 +2628,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2510	2628	"tmp.zig:2:20: error: no size available for type '(null)'",
2511	2629	});
2512	2630
2513		cases.add("generic function where return type is self-referenced",
	2631	ctx.objErrStage1("generic function where return type is self-referenced",
2514	2632	\\fn Foo(comptime T: type) Foo(T) {
2515	2633	\\ return struct{ x: T };
2516	2634	\\}
...	...	@@ -2518,34 +2636,37 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2518	2636	\\ const t = Foo(u32) {
2519	2637	\\ .x = 1
2520	2638	\\ };
	2639	\\ _ = t;
2521	2640	\\}
2522	2641	, &[_][]const u8{
2523	2642	"tmp.zig:1:29: error: evaluation exceeded 1000 backwards branches",
2524	2643	"tmp.zig:5:18: note: referenced here",
2525	2644	});
2526	2645
2527		cases.add("@ptrToInt 0 to non optional pointer",
	2646	ctx.objErrStage1("@ptrToInt 0 to non optional pointer",
2528	2647	\\export fn entry() void {
2529	2648	\\ var b = @intToPtr(*i32, 0);
	2649	\\ _ = b;
2530	2650	\\}
2531	2651	, &[_][]const u8{
2532	2652	"tmp.zig:2:13: error: pointer type '*i32' does not allow address zero",
2533	2653	});
2534	2654
2535		cases.add("cast enum literal to enum but it doesn't match",
	2655	ctx.objErrStage1("cast enum literal to enum but it doesn't match",
2536	2656	\\const Foo = enum {
2537	2657	\\ a,
2538	2658	\\ b,
2539	2659	\\};
2540	2660	\\export fn entry() void {
2541	2661	\\ const x: Foo = .c;
	2662	\\ _ = x;
2542	2663	\\}
2543	2664	, &[_][]const u8{
2544	2665	"tmp.zig:6:20: error: enum 'Foo' has no field named 'c'",
2545	2666	"tmp.zig:1:13: note: 'Foo' declared here",
2546	2667	});
2547	2668
2548		cases.add("discarding error value",
	2669	ctx.objErrStage1("discarding error value",
2549	2670	\\export fn entry() void {
2550	2671	\\ _ = foo();
2551	2672	\\}
...	...	@@ -2556,7 +2677,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2556	2677	"tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`",
2557	2678	});
2558	2679
2559		cases.add("volatile on global assembly",
	2680	ctx.objErrStage1("volatile on global assembly",
2560	2681	\\comptime {
2561	2682	\\ asm volatile ("");
2562	2683	\\}
...	...	@@ -2564,7 +2685,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2564	2685	"tmp.zig:2:9: error: volatile is meaningless on global assembly",
2565	2686	});
2566	2687
2567		cases.add("invalid multiple dereferences",
	2688	ctx.objErrStage1("invalid multiple dereferences",
2568	2689	\\export fn a() void {
2569	2690	\\ var box = Box{ .field = 0 };
2570	2691	\\ box.*.field = 1;
...	...	@@ -2582,13 +2703,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2582	2703	"tmp.zig:8:13: error: attempt to dereference non-pointer type 'Box'",
2583	2704	});
2584	2705
2585		cases.add("usingnamespace with wrong type",
	2706	ctx.objErrStage1("usingnamespace with wrong type",
2586	2707	\\usingnamespace void;
2587	2708	, &[_][]const u8{
2588	2709	"tmp.zig:1:1: error: expected struct, enum, or union; found 'void'",
2589	2710	});
2590	2711
2591		cases.add("ignored expression in while continuation",
	2712	ctx.objErrStage1("ignored expression in while continuation",
2592	2713	\\export fn a() void {
2593	2714	\\ while (true) : (bad()) {}
2594	2715	\\}
...	...	@@ -2609,31 +2730,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2609	2730	"tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`",
2610	2731	});
2611	2732
2612		cases.add("empty while loop body",
	2733	ctx.objErrStage1("empty while loop body",
2613	2734	\\export fn a() void {
2614	2735	\\ while(true);
2615	2736	\\}
2616	2737	, &[_][]const u8{
2617		"tmp.zig:2:16: error: expected loop body, found ';'",
	2738	"tmp.zig:2:16: error: expected block or assignment, found ';'",
2618	2739	});
2619	2740
2620		cases.add("empty for loop body",
	2741	ctx.objErrStage1("empty for loop body",
2621	2742	\\export fn a() void {
2622	2743	\\ for(undefined) \|x\|;
2623	2744	\\}
2624	2745	, &[_][]const u8{
2625		"tmp.zig:2:23: error: expected loop body, found ';'",
	2746	"tmp.zig:2:23: error: expected block or assignment, found ';'",
2626	2747	});
2627	2748
2628		cases.add("empty if body",
	2749	ctx.objErrStage1("empty if body",
2629	2750	\\export fn a() void {
2630	2751	\\ if(true);
2631	2752	\\}
2632	2753	, &[_][]const u8{
2633		"tmp.zig:2:13: error: expected if body, found ';'",
	2754	"tmp.zig:2:13: error: expected block or assignment, found ';'",
2634	2755	});
2635	2756
2636		cases.add("import outside package path",
	2757	ctx.objErrStage1("import outside package path",
2637	2758	\\comptime{
2638	2759	\\ _ = @import("../a.zig");
2639	2760	\\}
...	...	@@ -2641,14 +2762,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2641	2762	"tmp.zig:2:9: error: import of file outside package path: '../a.zig'",
2642	2763	});
2643	2764
2644		cases.add("bogus compile var",
	2765	ctx.objErrStage1("bogus compile var",
2645	2766	\\const x = @import("builtin").bogus;
2646	2767	\\export fn entry() usize { return @sizeOf(@TypeOf(x)); }
2647	2768	, &[_][]const u8{
2648	2769	"tmp.zig:1:29: error: container 'builtin' has no member called 'bogus'",
2649	2770	});
2650	2771
2651		cases.add("wrong panic signature, runtime function",
	2772	ctx.objErrStage1("wrong panic signature, runtime function",
2652	2773	\\test "" {}
2653	2774	\\
2654	2775	\\pub fn panic() void {}
...	...	@@ -2657,8 +2778,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2657	2778	"error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn() void'",
2658	2779	});
2659	2780
2660		cases.add("wrong panic signature, generic function",
	2781	ctx.objErrStage1("wrong panic signature, generic function",
2661	2782	\\pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
	2783	\\ _ = msg; _ = error_return_trace;
2662	2784	\\ while (true) {}
2663	2785	\\}
2664	2786	, &[_][]const u8{
...	...	@@ -2666,14 +2788,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2666	2788	"note: only one of the functions is generic",
2667	2789	});
2668	2790
2669		cases.add("direct struct loop",
	2791	ctx.objErrStage1("direct struct loop",
2670	2792	\\const A = struct { a : A, };
2671	2793	\\export fn entry() usize { return @sizeOf(A); }
2672	2794	, &[_][]const u8{
2673	2795	"tmp.zig:1:11: error: struct 'A' depends on itself",
2674	2796	});
2675	2797
2676		cases.add("indirect struct loop",
	2798	ctx.objErrStage1("indirect struct loop",
2677	2799	\\const A = struct { b : B, };
2678	2800	\\const B = struct { c : C, };
2679	2801	\\const C = struct { a : A, };
...	...	@@ -2682,7 +2804,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2682	2804	"tmp.zig:1:11: error: struct 'A' depends on itself",
2683	2805	});
2684	2806
2685		cases.add("instantiating an undefined value for an invalid struct that contains itself",
	2807	ctx.objErrStage1("instantiating an undefined value for an invalid struct that contains itself",
2686	2808	\\const Foo = struct {
2687	2809	\\ x: Foo,
2688	2810	\\};
...	...	@@ -2697,23 +2819,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2697	2819	"tmp.zig:8:28: note: referenced here",
2698	2820	});
2699	2821
2700		cases.add("enum field value references enum",
2701		\\pub const Foo = extern enum {
	2822	ctx.objErrStage1("enum field value references enum",
	2823	\\pub const Foo = enum(c_int) {
2702	2824	\\ A = Foo.B,
2703	2825	\\ C = D,
2704	2826	\\};
2705	2827	\\export fn entry() void {
2706	2828	\\ var s: Foo = Foo.E;
	2829	\\ _ = s;
2707	2830	\\}
2708	2831	, &[_][]const u8{
2709	2832	"tmp.zig:1:17: error: enum 'Foo' depends on itself",
2710	2833	});
2711	2834
2712		cases.add("top level decl dependency loop",
	2835	ctx.objErrStage1("top level decl dependency loop",
2713	2836	\\const a : @TypeOf(b) = 0;
2714	2837	\\const b : @TypeOf(a) = 0;
2715	2838	\\export fn entry() void {
2716	2839	\\ const c = a + b;
	2840	\\ _ = c;
2717	2841	\\}
2718	2842	, &[_][]const u8{
2719	2843	"tmp.zig:2:19: error: dependency loop detected",
...	...	@@ -2721,7 +2845,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2721	2845	"tmp.zig:4:15: note: referenced here",
2722	2846	});
2723	2847
2724		cases.addTest("not an enum type",
	2848	ctx.testErrStage1("not an enum type",
2725	2849	\\export fn entry() void {
2726	2850	\\ var self: Error = undefined;
2727	2851	\\ switch (self) {
...	...	@@ -2739,18 +2863,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2739	2863	"tmp.zig:4:9: error: expected type '@typeInfo(Error).Union.tag_type.?', found 'type'",
2740	2864	});
2741	2865
2742		cases.addTest("binary OR operator on error sets",
	2866	ctx.testErrStage1("binary OR operator on error sets",
2743	2867	\\pub const A = error.A;
2744	2868	\\pub const AB = A \| error.B;
2745	2869	\\export fn entry() void {
2746	2870	\\ var x: AB = undefined;
	2871	\\ _ = x;
2747	2872	\\}
2748	2873	, &[_][]const u8{
2749	2874	"tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'",
2750	2875	});
2751	2876
2752	2877	if (std.Target.current.os.tag == .linux) {
2753		cases.addTest("implicit dependency on libc",
	2878	ctx.testErrStage1("implicit dependency on libc",
2754	2879	\\extern "c" fn exit(u8) void;
2755	2880	\\export fn entry() void {
2756	2881	\\ exit(0);
...	...	@@ -2759,7 +2884,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2759	2884	"tmp.zig:3:5: error: dependency on libc must be explicitly specified in the build command",
2760	2885	});
2761	2886
2762		cases.addTest("libc headers note",
	2887	ctx.testErrStage1("libc headers note",
2763	2888	\\const c = @cImport(@cInclude("stdio.h"));
2764	2889	\\export fn entry() void {
2765	2890	\\ _ = c.printf("hello, world!\n");
...	...	@@ -2770,18 +2895,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2770	2895	});
2771	2896	}
2772	2897
2773		cases.addTest("comptime vector overflow shows the index",
	2898	ctx.testErrStage1("comptime vector overflow shows the index",
2774	2899	\\comptime {
2775	2900	\\ var a: @import("std").meta.Vector(4, u8) = [_]u8{ 1, 2, 255, 4 };
2776	2901	\\ var b: @import("std").meta.Vector(4, u8) = [_]u8{ 5, 6, 1, 8 };
2777	2902	\\ var x = a + b;
	2903	\\ _ = x;
2778	2904	\\}
2779	2905	, &[_][]const u8{
2780	2906	"tmp.zig:4:15: error: operation caused overflow",
2781	2907	"tmp.zig:4:15: note: when computing vector element at index 2",
2782	2908	});
2783	2909
2784		cases.addTest("packed struct with fields of not allowed types",
	2910	ctx.testErrStage1("packed struct with fields of not allowed types",
2785	2911	\\const A = packed struct {
2786	2912	\\ x: anyerror,
2787	2913	\\};
...	...	@@ -2805,24 +2931,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2805	2931	\\};
2806	2932	\\export fn entry1() void {
2807	2933	\\ var a: A = undefined;
	2934	\\ _ = a;
2808	2935	\\}
2809	2936	\\export fn entry2() void {
2810	2937	\\ var b: B = undefined;
	2938	\\ _ = b;
2811	2939	\\}
2812	2940	\\export fn entry3() void {
2813	2941	\\ var r: C = undefined;
	2942	\\ _ = r;
2814	2943	\\}
2815	2944	\\export fn entry4() void {
2816	2945	\\ var d: D = undefined;
	2946	\\ _ = d;
2817	2947	\\}
2818	2948	\\export fn entry5() void {
2819	2949	\\ var e: E = undefined;
	2950	\\ _ = e;
2820	2951	\\}
2821	2952	\\export fn entry6() void {
2822	2953	\\ var f: F = undefined;
	2954	\\ _ = f;
2823	2955	\\}
2824	2956	\\export fn entry7() void {
2825	2957	\\ var g: G = undefined;
	2958	\\ _ = g;
2826	2959	\\}
2827	2960	\\const S = struct {
2828	2961	\\ x: i32,
...	...	@@ -2843,42 +2976,40 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2843	2976	"tmp.zig:14:5: error: non-packed, non-extern struct 'U' not allowed in packed struct; no guaranteed in-memory representation",
2844	2977	"tmp.zig:17:5: error: type '?anyerror' not allowed in packed struct; no guaranteed in-memory representation",
2845	2978	"tmp.zig:20:5: error: type 'Enum' not allowed in packed struct; no guaranteed in-memory representation",
2846		"tmp.zig:50:14: note: enum declaration does not specify an integer tag type",
	2979	"tmp.zig:57:14: note: enum declaration does not specify an integer tag type",
2847	2980	});
2848	2981
2849		cases.addCase(x: {
2850		var tc = cases.create("deduplicate undeclared identifier",
2851		\\export fn a() void {
2852		\\ x += 1;
2853		\\}
2854		\\export fn b() void {
2855		\\ x += 1;
2856		\\}
2857		, &[_][]const u8{
2858		"tmp.zig:2:5: error: use of undeclared identifier 'x'",
2859		});
2860		tc.expect_exact = true;
2861		break :x tc;
	2982	ctx.objErrStage1("deduplicate undeclared identifier",
	2983	\\export fn a() void {
	2984	\\ x += 1;
	2985	\\}
	2986	\\export fn b() void {
	2987	\\ x += 1;
	2988	\\}
	2989	, &[_][]const u8{
	2990	"tmp.zig:2:5: error: use of undeclared identifier 'x'",
2862	2991	});
2863	2992
2864		cases.add("export generic function",
	2993	ctx.objErrStage1("export generic function",
2865	2994	\\export fn foo(num: anytype) i32 {
	2995	\\ _ = num;
2866	2996	\\ return 0;
2867	2997	\\}
2868	2998	, &[_][]const u8{
2869	2999	"tmp.zig:1:15: error: parameter of type 'anytype' not allowed in function with calling convention 'C'",
2870	3000	});
2871	3001
2872		cases.add("C pointer to c_void",
	3002	ctx.objErrStage1("C pointer to c_void",
2873	3003	\\export fn a() void {
2874	3004	\\ var x: *c_void = undefined;
2875	3005	\\ var y: [*c]c_void = x;
	3006	\\ _ = y;
2876	3007	\\}
2877	3008	, &[_][]const u8{
2878	3009	"tmp.zig:3:16: error: C pointers cannot point to opaque types",
2879	3010	});
2880	3011
2881		cases.add("directly embedding opaque type in struct and union",
	3012	ctx.objErrStage1("directly embedding opaque type in struct and union",
2882	3013	\\const O = opaque {};
2883	3014	\\const Foo = struct {
2884	3015	\\ o: O,
...	...	@@ -2889,74 +3020,85 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2889	3020	\\};
2890	3021	\\export fn a() void {
2891	3022	\\ var foo: Foo = undefined;
	3023	\\ _ = foo;
2892	3024	\\}
2893	3025	\\export fn b() void {
2894	3026	\\ var bar: Bar = undefined;
	3027	\\ _ = bar;
2895	3028	\\}
2896	3029	\\export fn c() void {
2897	3030	\\ var baz: *opaque {} = undefined;
2898	3031	\\ const qux = .{baz.*};
	3032	\\ _ = qux;
2899	3033	\\}
2900	3034	, &[_][]const u8{
2901	3035	"tmp.zig:3:5: error: opaque types have unknown size and therefore cannot be directly embedded in structs",
2902	3036	"tmp.zig:7:5: error: opaque types have unknown size and therefore cannot be directly embedded in unions",
2903		"tmp.zig:17:22: error: opaque types have unknown size and therefore cannot be directly embedded in structs",
	3037	"tmp.zig:19:22: error: opaque types have unknown size and therefore cannot be directly embedded in structs",
2904	3038	});
2905	3039
2906		cases.add("implicit cast between C pointer and Zig pointer - bad const/align/child",
	3040	ctx.objErrStage1("implicit cast between C pointer and Zig pointer - bad const/align/child",
2907	3041	\\export fn a() void {
2908	3042	\\ var x: [*c]u8 = undefined;
2909	3043	\\ var y: *align(4) u8 = x;
	3044	\\ _ = y;
2910	3045	\\}
2911	3046	\\export fn b() void {
2912	3047	\\ var x: [*c]const u8 = undefined;
2913	3048	\\ var y: *u8 = x;
	3049	\\ _ = y;
2914	3050	\\}
2915	3051	\\export fn c() void {
2916	3052	\\ var x: [*c]u8 = undefined;
2917	3053	\\ var y: *u32 = x;
	3054	\\ _ = y;
2918	3055	\\}
2919	3056	\\export fn d() void {
2920	3057	\\ var y: *align(1) u32 = undefined;
2921	3058	\\ var x: [*c]u32 = y;
	3059	\\ _ = x;
2922	3060	\\}
2923	3061	\\export fn e() void {
2924	3062	\\ var y: *const u8 = undefined;
2925	3063	\\ var x: [*c]u8 = y;
	3064	\\ _ = x;
2926	3065	\\}
2927	3066	\\export fn f() void {
2928	3067	\\ var y: *u8 = undefined;
2929	3068	\\ var x: [*c]u32 = y;
	3069	\\ _ = x;
2930	3070	\\}
2931	3071	, &[_][]const u8{
2932	3072	"tmp.zig:3:27: error: cast increases pointer alignment",
2933		"tmp.zig:7:18: error: cast discards const qualifier",
2934		"tmp.zig:11:19: error: expected type 'u32', found '[c]u8'",
2935		"tmp.zig:11:19: note: pointer type child 'u8' cannot cast into pointer type child 'u32'",
2936		"tmp.zig:15:22: error: cast increases pointer alignment",
2937		"tmp.zig:19:21: error: cast discards const qualifier",
2938		"tmp.zig:23:22: error: expected type '[c]u32', found 'u8'",
	3073	"tmp.zig:8:18: error: cast discards const qualifier",
	3074	"tmp.zig:13:19: error: expected type 'u32', found '[c]u8'",
	3075	"tmp.zig:13:19: note: pointer type child 'u8' cannot cast into pointer type child 'u32'",
	3076	"tmp.zig:18:22: error: cast increases pointer alignment",
	3077	"tmp.zig:23:21: error: cast discards const qualifier",
	3078	"tmp.zig:28:22: error: expected type '[c]u32', found 'u8'",
2939	3079	});
2940	3080
2941		cases.add("implicit casting null c pointer to zig pointer",
	3081	ctx.objErrStage1("implicit casting null c pointer to zig pointer",
2942	3082	\\comptime {
2943	3083	\\ var c_ptr: [*c]u8 = 0;
2944	3084	\\ var zig_ptr: *u8 = c_ptr;
	3085	\\ _ = zig_ptr;
2945	3086	\\}
2946	3087	, &[_][]const u8{
2947	3088	"tmp.zig:3:24: error: null pointer casted to type '*u8'",
2948	3089	});
2949	3090
2950		cases.add("implicit casting undefined c pointer to zig pointer",
	3091	ctx.objErrStage1("implicit casting undefined c pointer to zig pointer",
2951	3092	\\comptime {
2952	3093	\\ var c_ptr: [*c]u8 = undefined;
2953	3094	\\ var zig_ptr: *u8 = c_ptr;
	3095	\\ _ = zig_ptr;
2954	3096	\\}
2955	3097	, &[_][]const u8{
2956	3098	"tmp.zig:3:24: error: use of undefined value here causes undefined behavior",
2957	3099	});
2958	3100
2959		cases.add("implicit casting C pointers which would mess up null semantics",
	3101	ctx.objErrStage1("implicit casting C pointers which would mess up null semantics",
2960	3102	\\export fn entry() void {
2961	3103	\\ var slice: []const u8 = "aoeu";
2962	3104	\\ const opt_many_ptr: [*]const u8 = slice.ptr;
...	...	@@ -2970,6 +3112,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2970	3112	\\ var opt_many_ptr: [*]u8 = slice.ptr;
2971	3113	\\ var ptr_opt_many_ptr = &opt_many_ptr;
2972	3114	\\ var c_ptr: [c][c]const u8 = ptr_opt_many_ptr;
	3115	\\ _ = c_ptr;
2973	3116	\\}
2974	3117	, &[_][]const u8{
2975	3118	"tmp.zig:6:24: error: expected type 'const []const u8', found '[c]const [c]const u8'",
...	...	@@ -2980,47 +3123,46 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2980	3123	"tmp.zig:13:35: note: mutable '[c]const u8' allows illegal null values stored to type '[]u8'",
2981	3124	});
2982	3125
2983		cases.add("implicit casting too big integers to C pointers",
	3126	ctx.objErrStage1("implicit casting too big integers to C pointers",
2984	3127	\\export fn a() void {
2985	3128	\\ var ptr: [*c]u8 = (1 << 64) + 1;
	3129	\\ _ = ptr;
2986	3130	\\}
2987	3131	\\export fn b() void {
2988	3132	\\ var x: u65 = 0x1234;
2989	3133	\\ var ptr: [*c]u8 = x;
	3134	\\ _ = ptr;
2990	3135	\\}
2991	3136	, &[_][]const u8{
2992	3137	"tmp.zig:2:33: error: integer value 18446744073709551617 cannot be coerced to type 'usize'",
2993		"tmp.zig:6:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'",
	3138	"tmp.zig:7:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'",
2994	3139	});
2995	3140
2996		cases.add("C pointer pointing to non C ABI compatible type or has align attr",
	3141	ctx.objErrStage1("C pointer pointing to non C ABI compatible type or has align attr",
2997	3142	\\const Foo = struct {};
2998	3143	\\export fn a() void {
2999	3144	\\ const T = [*c]Foo;
3000	3145	\\ var t: T = undefined;
	3146	\\ _ = t;
3001	3147	\\}
3002	3148	, &[_][]const u8{
3003	3149	"tmp.zig:3:19: error: C pointers cannot point to non-C-ABI-compatible type 'Foo'",
3004	3150	});
3005	3151
3006		cases.addCase(x: {
3007		var tc = cases.create("compile log statement warning deduplication in generic fn",
3008		\\export fn entry() void {
3009		\\ inner(1);
3010		\\ inner(2);
3011		\\}
3012		\\fn inner(comptime n: usize) void {
3013		\\ comptime var i = 0;
3014		\\ inline while (i < n) : (i += 1) { @compileLog("!@#$"); }
3015		\\}
3016		, &[_][]const u8{
3017		"tmp.zig:7:39: error: found compile log statement",
3018		});
3019		tc.expect_exact = true;
3020		break :x tc;
	3152	ctx.objErrStage1("compile log statement warning deduplication in generic fn",
	3153	\\export fn entry() void {
	3154	\\ inner(1);
	3155	\\ inner(2);
	3156	\\}
	3157	\\fn inner(comptime n: usize) void {
	3158	\\ comptime var i = 0;
	3159	\\ inline while (i < n) : (i += 1) { @compileLog("!@#$"); }
	3160	\\}
	3161	, &[_][]const u8{
	3162	"tmp.zig:7:39: error: found compile log statement",
3021	3163	});
3022	3164
3023		cases.add("assign to invalid dereference",
	3165	ctx.objErrStage1("assign to invalid dereference",
3024	3166	\\export fn entry() void {
3025	3167	\\ 'a'.* = 1;
3026	3168	\\}
...	...	@@ -3028,54 +3170,58 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3028	3170	"tmp.zig:2:8: error: attempt to dereference non-pointer type 'comptime_int'",
3029	3171	});
3030	3172
3031		cases.add("take slice of invalid dereference",
	3173	ctx.objErrStage1("take slice of invalid dereference",
3032	3174	\\export fn entry() void {
3033	3175	\\ const x = 'a'.*[0..];
	3176	\\ _ = x;
3034	3177	\\}
3035	3178	, &[_][]const u8{
3036	3179	"tmp.zig:2:18: error: attempt to dereference non-pointer type 'comptime_int'",
3037	3180	});
3038	3181
3039		cases.add("@truncate undefined value",
	3182	ctx.objErrStage1("@truncate undefined value",
3040	3183	\\export fn entry() void {
3041	3184	\\ var z = @truncate(u8, @as(u16, undefined));
	3185	\\ _ = z;
3042	3186	\\}
3043	3187	, &[_][]const u8{
3044	3188	"tmp.zig:2:27: error: use of undefined value here causes undefined behavior",
3045	3189	});
3046	3190
3047		cases.addTest("return invalid type from test",
	3191	ctx.testErrStage1("return invalid type from test",
3048	3192	\\test "example" { return 1; }
3049	3193	, &[_][]const u8{
3050	3194	"tmp.zig:1:25: error: expected type 'void', found 'comptime_int'",
3051	3195	});
3052	3196
3053		cases.add("threadlocal qualifier on const",
	3197	ctx.objErrStage1("threadlocal qualifier on const",
3054	3198	\\threadlocal const x: i32 = 1234;
3055	3199	\\export fn entry() i32 {
3056	3200	\\ return x;
3057	3201	\\}
3058	3202	, &[_][]const u8{
3059		"tmp.zig:1:13: error: threadlocal variable cannot be constant",
	3203	"tmp.zig:1:1: error: threadlocal variable cannot be constant",
3060	3204	});
3061	3205
3062		cases.add("@bitCast same size but bit count mismatch",
	3206	ctx.objErrStage1("@bitCast same size but bit count mismatch",
3063	3207	\\export fn entry(byte: u8) void {
3064	3208	\\ var oops = @bitCast(u7, byte);
	3209	\\ _ = oops;
3065	3210	\\}
3066	3211	, &[_][]const u8{
3067	3212	"tmp.zig:2:25: error: destination type 'u7' has 7 bits but source type 'u8' has 8 bits",
3068	3213	});
3069	3214
3070		cases.add("@bitCast with different sizes inside an expression",
	3215	ctx.objErrStage1("@bitCast with different sizes inside an expression",
3071	3216	\\export fn entry() void {
3072	3217	\\ var foo = (@bitCast(u8, @as(f32, 1.0)) == 0xf);
	3218	\\ _ = foo;
3073	3219	\\}
3074	3220	, &[_][]const u8{
3075	3221	"tmp.zig:2:25: error: destination type 'u8' has size 1 but source type 'f32' has size 4",
3076	3222	});
3077	3223
3078		cases.add("attempted `&&`",
	3224	ctx.objErrStage1("attempted `&&`",
3079	3225	\\export fn entry(a: bool, b: bool) i32 {
3080	3226	\\ if (a && b) {
3081	3227	\\ return 1234;
...	...	@@ -3083,10 +3229,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3083	3229	\\ return 5678;
3084	3230	\\}
3085	3231	, &[_][]const u8{
3086		"tmp.zig:2:12: error: `&&` is invalid. Note that `and` is boolean AND",
	3232	"tmp.zig:2:11: error: `&&` is invalid; note that `and` is boolean AND",
3087	3233	});
3088	3234
3089		cases.add("attempted `\|\|` on boolean values",
	3235	ctx.objErrStage1("attempted `\|\|` on boolean values",
3090	3236	\\export fn entry(a: bool, b: bool) i32 {
3091	3237	\\ if (a \|\| b) {
3092	3238	\\ return 1234;
...	...	@@ -3098,7 +3244,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3098	3244	"tmp.zig:2:11: note: `\|\|` merges error sets; `or` performs boolean OR",
3099	3245	});
3100	3246
3101		cases.add("compile log a pointer to an opaque value",
	3247	ctx.objErrStage1("compile log a pointer to an opaque value",
3102	3248	\\export fn entry() void {
3103	3249	\\ @compileLog(@ptrCast(*const c_void, &entry));
3104	3250	\\}
...	...	@@ -3106,13 +3252,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3106	3252	"tmp.zig:2:5: error: found compile log statement",
3107	3253	});
3108	3254
3109		cases.add("duplicate boolean switch value",
	3255	ctx.objErrStage1("duplicate boolean switch value",
3110	3256	\\comptime {
3111	3257	\\ const x = switch (true) {
3112	3258	\\ true => false,
3113	3259	\\ false => true,
3114	3260	\\ true => false,
3115	3261	\\ };
	3262	\\ _ = x;
3116	3263	\\}
3117	3264	\\comptime {
3118	3265	\\ const x = switch (true) {
...	...	@@ -3120,42 +3267,46 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3120	3267	\\ true => false,
3121	3268	\\ false => true,
3122	3269	\\ };
	3270	\\ _ = x;
3123	3271	\\}
3124	3272	, &[_][]const u8{
3125	3273	"tmp.zig:5:9: error: duplicate switch value",
3126		"tmp.zig:12:9: error: duplicate switch value",
	3274	"tmp.zig:13:9: error: duplicate switch value",
3127	3275	});
3128	3276
3129		cases.add("missing boolean switch value",
	3277	ctx.objErrStage1("missing boolean switch value",
3130	3278	\\comptime {
3131	3279	\\ const x = switch (true) {
3132	3280	\\ true => false,
3133	3281	\\ };
	3282	\\ _ = x;
3134	3283	\\}
3135	3284	\\comptime {
3136	3285	\\ const x = switch (true) {
3137	3286	\\ false => true,
3138	3287	\\ };
	3288	\\ _ = x;
3139	3289	\\}
3140	3290	, &[_][]const u8{
3141	3291	"tmp.zig:2:15: error: switch must handle all possibilities",
3142		"tmp.zig:7:15: error: switch must handle all possibilities",
	3292	"tmp.zig:8:15: error: switch must handle all possibilities",
3143	3293	});
3144	3294
3145		cases.add("reading past end of pointer casted array",
	3295	ctx.objErrStage1("reading past end of pointer casted array",
3146	3296	\\comptime {
3147	3297	\\ const array: [4]u8 = "aoeu".*;
3148	3298	\\ const sub_array = array[1..];
3149	3299	\\ const int_ptr = @ptrCast(*const u24, sub_array);
3150	3300	\\ const deref = int_ptr.*;
	3301	\\ _ = deref;
3151	3302	\\}
3152	3303	, &[_][]const u8{
3153	3304	"tmp.zig:5:26: error: attempt to read 4 bytes from [4]u8 at index 1 which is 3 bytes",
3154	3305	});
3155	3306
3156		cases.add("error note for function parameter incompatibility",
3157		\\fn do_the_thing(func: fn (arg: i32) void) void {}
3158		\\fn bar(arg: bool) void {}
	3307	ctx.objErrStage1("error note for function parameter incompatibility",
	3308	\\fn do_the_thing(func: fn (arg: i32) void) void { _ = func; }
	3309	\\fn bar(arg: bool) void { _ = arg; }
3159	3310	\\export fn entry() void {
3160	3311	\\ do_the_thing(bar);
3161	3312	\\}
...	...	@@ -3163,56 +3314,63 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3163	3314	"tmp.zig:4:18: error: expected type 'fn(i32) void', found 'fn(bool) void",
3164	3315	"tmp.zig:4:18: note: parameter 0: 'bool' cannot cast into 'i32'",
3165	3316	});
3166		cases.add("cast negative value to unsigned integer",
	3317	ctx.objErrStage1("cast negative value to unsigned integer",
3167	3318	\\comptime {
3168	3319	\\ const value: i32 = -1;
3169	3320	\\ const unsigned = @intCast(u32, value);
	3321	\\ _ = unsigned;
3170	3322	\\}
3171	3323	\\export fn entry1() void {
3172	3324	\\ const value: i32 = -1;
3173	3325	\\ const unsigned: u32 = value;
	3326	\\ _ = unsigned;
3174	3327	\\}
3175	3328	, &[_][]const u8{
3176	3329	"tmp.zig:3:22: error: attempt to cast negative value to unsigned integer",
3177		"tmp.zig:7:27: error: cannot cast negative value -1 to unsigned integer type 'u32'",
	3330	"tmp.zig:8:27: error: cannot cast negative value -1 to unsigned integer type 'u32'",
3178	3331	});
3179	3332
3180		cases.add("integer cast truncates bits",
	3333	ctx.objErrStage1("integer cast truncates bits",
3181	3334	\\export fn entry1() void {
3182	3335	\\ const spartan_count: u16 = 300;
3183	3336	\\ const byte = @intCast(u8, spartan_count);
	3337	\\ _ = byte;
3184	3338	\\}
3185	3339	\\export fn entry2() void {
3186	3340	\\ const spartan_count: u16 = 300;
3187	3341	\\ const byte: u8 = spartan_count;
	3342	\\ _ = byte;
3188	3343	\\}
3189	3344	\\export fn entry3() void {
3190	3345	\\ var spartan_count: u16 = 300;
3191	3346	\\ var byte: u8 = spartan_count;
	3347	\\ _ = byte;
3192	3348	\\}
3193	3349	\\export fn entry4() void {
3194	3350	\\ var signed: i8 = -1;
3195	3351	\\ var unsigned: u64 = signed;
	3352	\\ _ = unsigned;
3196	3353	\\}
3197	3354	, &[_][]const u8{
3198	3355	"tmp.zig:3:18: error: cast from 'u16' to 'u8' truncates bits",
3199		"tmp.zig:7:22: error: integer value 300 cannot be coerced to type 'u8'",
3200		"tmp.zig:11:20: error: expected type 'u8', found 'u16'",
3201		"tmp.zig:11:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values",
3202		"tmp.zig:15:25: error: expected type 'u64', found 'i8'",
3203		"tmp.zig:15:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values",
	3356	"tmp.zig:8:22: error: integer value 300 cannot be coerced to type 'u8'",
	3357	"tmp.zig:13:20: error: expected type 'u8', found 'u16'",
	3358	"tmp.zig:13:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values",
	3359	"tmp.zig:18:25: error: expected type 'u64', found 'i8'",
	3360	"tmp.zig:18:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values",
3204	3361	});
3205	3362
3206		cases.add("comptime implicit cast f64 to f32",
	3363	ctx.objErrStage1("comptime implicit cast f64 to f32",
3207	3364	\\export fn entry() void {
3208	3365	\\ const x: f64 = 16777217;
3209	3366	\\ const y: f32 = x;
	3367	\\ _ = y;
3210	3368	\\}
3211	3369	, &[_][]const u8{
3212	3370	"tmp.zig:3:20: error: cast of value 16777217.000000 to type 'f32' loses information",
3213	3371	});
3214	3372
3215		cases.add("implicit cast from f64 to f32",
	3373	ctx.objErrStage1("implicit cast from f64 to f32",
3216	3374	\\var x: f64 = 1.0;
3217	3375	\\var y: f32 = x;
3218	3376	\\
...	...	@@ -3221,41 +3379,46 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3221	3379	"tmp.zig:2:14: error: expected type 'f32', found 'f64'",
3222	3380	});
3223	3381
3224		cases.add("exceeded maximum bit width of integer",
	3382	ctx.objErrStage1("exceeded maximum bit width of integer",
3225	3383	\\export fn entry1() void {
3226	3384	\\ const T = u65536;
	3385	\\ _ = T;
3227	3386	\\}
3228	3387	\\export fn entry2() void {
3229	3388	\\ var x: i65536 = 1;
	3389	\\ _ = x;
3230	3390	\\}
3231	3391	, &[_][]const u8{
3232		"tmp.zig:5:12: error: primitive integer type 'i65536' exceeds maximum bit width of 65535",
	3392	"tmp.zig:2:15: error: primitive integer type 'u65536' exceeds maximum bit width of 65535",
	3393	"tmp.zig:6:12: error: primitive integer type 'i65536' exceeds maximum bit width of 65535",
3233	3394	});
3234	3395
3235		cases.add("compile error when evaluating return type of inferred error set",
	3396	ctx.objErrStage1("compile error when evaluating return type of inferred error set",
3236	3397	\\const Car = struct {
3237	3398	\\ foo: *SymbolThatDoesNotExist,
3238	3399	\\ pub fn init() !Car {}
3239	3400	\\};
3240	3401	\\export fn entry() void {
3241	3402	\\ const car = Car.init();
	3403	\\ _ = car;
3242	3404	\\}
3243	3405	, &[_][]const u8{
3244	3406	"tmp.zig:2:11: error: use of undeclared identifier 'SymbolThatDoesNotExist'",
3245	3407	});
3246	3408
3247		cases.add("don't implicit cast double pointer to *c_void",
	3409	ctx.objErrStage1("don't implicit cast double pointer to *c_void",
3248	3410	\\export fn entry() void {
3249	3411	\\ var a: u32 = 1;
3250	3412	\\ var ptr: *align(@alignOf(u32)) c_void = &a;
3251	3413	\\ var b: u32 = @ptrCast(u32, ptr);
3252	3414	\\ var ptr2: *c_void = &b;
	3415	\\ _ = ptr2;
3253	3416	\\}
3254	3417	, &[_][]const u8{
3255	3418	"tmp.zig:5:26: error: expected type 'c_void', found '*u32'",
3256	3419	});
3257	3420
3258		cases.add("runtime index into comptime type slice",
	3421	ctx.objErrStage1("runtime index into comptime type slice",
3259	3422	\\const Struct = struct {
3260	3423	\\ a: u32,
3261	3424	\\};
...	...	@@ -3265,12 +3428,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3265	3428	\\export fn entry() void {
3266	3429	\\ const index = getIndex();
3267	3430	\\ const field = @typeInfo(Struct).Struct.fields[index];
	3431	\\ _ = field;
3268	3432	\\}
3269	3433	, &[_][]const u8{
3270	3434	"tmp.zig:9:51: error: values of type 'std.builtin.StructField' must be comptime known, but index value is runtime known",
3271	3435	});
3272	3436
3273		cases.add("compile log statement inside function which must be comptime evaluated",
	3437	ctx.objErrStage1("compile log statement inside function which must be comptime evaluated",
3274	3438	\\fn Foo(comptime T: type) type {
3275	3439	\\ @compileLog(@typeName(T));
3276	3440	\\ return T;
...	...	@@ -3283,25 +3447,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3283	3447	"tmp.zig:2:5: error: found compile log statement",
3284	3448	});
3285	3449
3286		cases.add("comptime slice of an undefined slice",
	3450	ctx.objErrStage1("comptime slice of an undefined slice",
3287	3451	\\comptime {
3288	3452	\\ var a: []u8 = undefined;
3289	3453	\\ var b = a[0..10];
	3454	\\ _ = b;
3290	3455	\\}
3291	3456	, &[_][]const u8{
3292	3457	"tmp.zig:3:14: error: slice of undefined",
3293	3458	});
3294	3459
3295		cases.add("implicit cast const array to mutable slice",
	3460	ctx.objErrStage1("implicit cast const array to mutable slice",
3296	3461	\\export fn entry() void {
3297	3462	\\ const buffer: [1]u8 = [_]u8{8};
3298	3463	\\ const sliceA: []u8 = &buffer;
	3464	\\ _ = sliceA;
3299	3465	\\}
3300	3466	, &[_][]const u8{
3301	3467	"tmp.zig:3:27: error: expected type '[]u8', found '*const [1]u8'",
3302	3468	});
3303	3469
3304		cases.add("deref slice and get len field",
	3470	ctx.objErrStage1("deref slice and get len field",
3305	3471	\\export fn entry() void {
3306	3472	\\ var a: []u8 = undefined;
3307	3473	\\ _ = a.*.len;
...	...	@@ -3310,7 +3476,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3310	3476	"tmp.zig:3:10: error: attempt to dereference non-pointer type '[]u8'",
3311	3477	});
3312	3478
3313		cases.add("@ptrCast a 0 bit type to a non- 0 bit type",
	3479	ctx.objErrStage1("@ptrCast a 0 bit type to a non- 0 bit type",
3314	3480	\\export fn entry() bool {
3315	3481	\\ var x: u0 = 0;
3316	3482	\\ const p = @ptrCast(?*u0, &x);
...	...	@@ -3322,7 +3488,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3322	3488	"tmp.zig:3:24: note: '?*u0' has in-memory bits",
3323	3489	});
3324	3490
3325		cases.add("comparing a non-optional pointer against null",
	3491	ctx.objErrStage1("comparing a non-optional pointer against null",
3326	3492	\\export fn entry() void {
3327	3493	\\ var x: i32 = 1;
3328	3494	\\ _ = &x == null;
...	...	@@ -3331,21 +3497,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3331	3497	"tmp.zig:3:12: error: comparison of '*i32' with null",
3332	3498	});
3333	3499
3334		cases.add("non error sets used in merge error sets operator",
	3500	ctx.objErrStage1("non error sets used in merge error sets operator",
3335	3501	\\export fn foo() void {
3336	3502	\\ const Errors = u8 \|\| u16;
	3503	\\ _ = Errors;
3337	3504	\\}
3338	3505	\\export fn bar() void {
3339	3506	\\ const Errors = error{} \|\| u16;
	3507	\\ _ = Errors;
3340	3508	\\}
3341	3509	, &[_][]const u8{
3342	3510	"tmp.zig:2:20: error: expected error set type, found type 'u8'",
3343	3511	"tmp.zig:2:23: note: `\|\|` merges error sets; `or` performs boolean OR",
3344		"tmp.zig:5:31: error: expected error set type, found type 'u16'",
3345		"tmp.zig:5:28: note: `\|\|` merges error sets; `or` performs boolean OR",
	3512	"tmp.zig:6:31: error: expected error set type, found type 'u16'",
	3513	"tmp.zig:6:28: note: `\|\|` merges error sets; `or` performs boolean OR",
3346	3514	});
3347	3515
3348		cases.add("variable initialization compile error then referenced",
	3516	ctx.objErrStage1("variable initialization compile error then referenced",
3349	3517	\\fn Undeclared() type {
3350	3518	\\ return T;
3351	3519	\\}
...	...	@@ -3357,12 +3525,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3357	3525	\\}
3358	3526	\\export fn entry() void {
3359	3527	\\ const S = Gen();
	3528	\\ _ = S;
3360	3529	\\}
3361	3530	, &[_][]const u8{
3362	3531	"tmp.zig:2:12: error: use of undeclared identifier 'T'",
3363	3532	});
3364	3533
3365		cases.add("refer to the type of a generic function",
	3534	ctx.objErrStage1("refer to the type of a generic function",
3366	3535	\\export fn entry() void {
3367	3536	\\ const Func = fn (type) void;
3368	3537	\\ const f: Func = undefined;
...	...	@@ -3372,7 +3541,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3372	3541	"tmp.zig:4:5: error: use of undefined value here causes undefined behavior",
3373	3542	});
3374	3543
3375		cases.add("accessing runtime parameter from outer function",
	3544	ctx.objErrStage1("accessing runtime parameter from outer function",
3376	3545	\\fn outer(y: u32) fn (u32) u32 {
3377	3546	\\ const st = struct {
3378	3547	\\ fn get(z: u32) u32 {
...	...	@@ -3384,6 +3553,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3384	3553	\\export fn entry() void {
3385	3554	\\ var func = outer(10);
3386	3555	\\ var x = func(3);
	3556	\\ _ = x;
3387	3557	\\}
3388	3558	, &[_][]const u8{
3389	3559	"tmp.zig:4:24: error: 'y' not accessible from inner function",
...	...	@@ -3391,69 +3561,74 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3391	3561	"tmp.zig:1:10: note: declared here",
3392	3562	});
3393	3563
3394		cases.add("non int passed to @intToFloat",
	3564	ctx.objErrStage1("non int passed to @intToFloat",
3395	3565	\\export fn entry() void {
3396	3566	\\ const x = @intToFloat(f32, 1.1);
	3567	\\ _ = x;
3397	3568	\\}
3398	3569	, &[_][]const u8{
3399	3570	"tmp.zig:2:32: error: expected int type, found 'comptime_float'",
3400	3571	});
3401	3572
3402		cases.add("non float passed to @floatToInt",
	3573	ctx.objErrStage1("non float passed to @floatToInt",
3403	3574	\\export fn entry() void {
3404	3575	\\ const x = @floatToInt(i32, @as(i32, 54));
	3576	\\ _ = x;
3405	3577	\\}
3406	3578	, &[_][]const u8{
3407	3579	"tmp.zig:2:32: error: expected float type, found 'i32'",
3408	3580	});
3409	3581
3410		cases.add("out of range comptime_int passed to @floatToInt",
	3582	ctx.objErrStage1("out of range comptime_int passed to @floatToInt",
3411	3583	\\export fn entry() void {
3412	3584	\\ const x = @floatToInt(i8, 200);
	3585	\\ _ = x;
3413	3586	\\}
3414	3587	, &[_][]const u8{
3415	3588	"tmp.zig:2:31: error: integer value 200 cannot be coerced to type 'i8'",
3416	3589	});
3417	3590
3418		cases.add("load too many bytes from comptime reinterpreted pointer",
	3591	ctx.objErrStage1("load too many bytes from comptime reinterpreted pointer",
3419	3592	\\export fn entry() void {
3420	3593	\\ const float: f32 = 5.99999999999994648725e-01;
3421	3594	\\ const float_ptr = &float;
3422	3595	\\ const int_ptr = @ptrCast(*const i64, float_ptr);
3423	3596	\\ const int_val = int_ptr.*;
	3597	\\ _ = int_val;
3424	3598	\\}
3425	3599	, &[_][]const u8{
3426	3600	"tmp.zig:5:28: error: attempt to read 8 bytes from pointer to f32 which is 4 bytes",
3427	3601	});
3428	3602
3429		cases.add("invalid type used in array type",
	3603	ctx.objErrStage1("invalid type used in array type",
3430	3604	\\const Item = struct {
3431	3605	\\ field: SomeNonexistentType,
3432	3606	\\};
3433	3607	\\var items: [100]Item = undefined;
3434	3608	\\export fn entry() void {
3435	3609	\\ const a = items[0];
	3610	\\ _ = a;
3436	3611	\\}
3437	3612	, &[_][]const u8{
3438	3613	"tmp.zig:2:12: error: use of undeclared identifier 'SomeNonexistentType'",
3439	3614	});
3440	3615
3441		cases.add("comptime continue inside runtime catch",
3442		\\export fn entry(c: bool) void {
	3616	ctx.objErrStage1("comptime continue inside runtime catch",
	3617	\\export fn entry() void {
3443	3618	\\ const ints = [_]u8{ 1, 2 };
3444	3619	\\ inline for (ints) \|_\| {
3445		\\ bad() catch \|_\| continue;
	3620	\\ bad() catch continue;
3446	3621	\\ }
3447	3622	\\}
3448	3623	\\fn bad() !void {
3449	3624	\\ return error.Bad;
3450	3625	\\}
3451	3626	, &[_][]const u8{
3452		"tmp.zig:4:25: error: comptime control flow inside runtime block",
	3627	"tmp.zig:4:21: error: comptime control flow inside runtime block",
3453	3628	"tmp.zig:4:15: note: runtime block created here",
3454	3629	});
3455	3630
3456		cases.add("comptime continue inside runtime switch",
	3631	ctx.objErrStage1("comptime continue inside runtime switch",
3457	3632	\\export fn entry() void {
3458	3633	\\ var p: i32 = undefined;
3459	3634	\\ comptime var q = true;
...	...	@@ -3470,7 +3645,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3470	3645	"tmp.zig:5:9: note: runtime block created here",
3471	3646	});
3472	3647
3473		cases.add("comptime continue inside runtime while error",
	3648	ctx.objErrStage1("comptime continue inside runtime while error",
3474	3649	\\export fn entry() void {
3475	3650	\\ var p: anyerror!usize = undefined;
3476	3651	\\ comptime var q = true;
...	...	@@ -3486,7 +3661,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3486	3661	"tmp.zig:5:9: note: runtime block created here",
3487	3662	});
3488	3663
3489		cases.add("comptime continue inside runtime while optional",
	3664	ctx.objErrStage1("comptime continue inside runtime while optional",
3490	3665	\\export fn entry() void {
3491	3666	\\ var p: ?usize = undefined;
3492	3667	\\ comptime var q = true;
...	...	@@ -3500,7 +3675,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3500	3675	"tmp.zig:5:9: note: runtime block created here",
3501	3676	});
3502	3677
3503		cases.add("comptime continue inside runtime while bool",
	3678	ctx.objErrStage1("comptime continue inside runtime while bool",
3504	3679	\\export fn entry() void {
3505	3680	\\ var p: usize = undefined;
3506	3681	\\ comptime var q = true;
...	...	@@ -3514,7 +3689,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3514	3689	"tmp.zig:5:9: note: runtime block created here",
3515	3690	});
3516	3691
3517		cases.add("comptime continue inside runtime if error",
	3692	ctx.objErrStage1("comptime continue inside runtime if error",
3518	3693	\\export fn entry() void {
3519	3694	\\ var p: anyerror!i32 = undefined;
3520	3695	\\ comptime var q = true;
...	...	@@ -3528,7 +3703,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3528	3703	"tmp.zig:5:9: note: runtime block created here",
3529	3704	});
3530	3705
3531		cases.add("comptime continue inside runtime if optional",
	3706	ctx.objErrStage1("comptime continue inside runtime if optional",
3532	3707	\\export fn entry() void {
3533	3708	\\ var p: ?i32 = undefined;
3534	3709	\\ comptime var q = true;
...	...	@@ -3542,7 +3717,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3542	3717	"tmp.zig:5:9: note: runtime block created here",
3543	3718	});
3544	3719
3545		cases.add("comptime continue inside runtime if bool",
	3720	ctx.objErrStage1("comptime continue inside runtime if bool",
3546	3721	\\export fn entry() void {
3547	3722	\\ var p: usize = undefined;
3548	3723	\\ comptime var q = true;
...	...	@@ -3556,22 +3731,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3556	3731	"tmp.zig:5:9: note: runtime block created here",
3557	3732	});
3558	3733
3559		cases.add("switch with invalid expression parameter",
	3734	ctx.objErrStage1("switch with invalid expression parameter",
3560	3735	\\export fn entry() void {
3561	3736	\\ Test(i32);
3562	3737	\\}
3563	3738	\\fn Test(comptime T: type) void {
3564	3739	\\ const x = switch (T) {
3565		\\ []u8 => \|x\| 123,
3566		\\ i32 => \|x\| 456,
	3740	\\ []u8 => \|x\| x,
	3741	\\ i32 => \|x\| x,
3567	3742	\\ else => unreachable,
3568	3743	\\ };
	3744	\\ _ = x;
3569	3745	\\}
3570	3746	, &[_][]const u8{
3571	3747	"tmp.zig:7:17: error: switch on type 'type' provides no expression parameter",
3572	3748	});
3573	3749
3574		cases.add("function prototype with no body",
	3750	ctx.objErrStage1("function prototype with no body",
3575	3751	\\fn foo() void;
3576	3752	\\export fn entry() void {
3577	3753	\\ foo();
...	...	@@ -3580,7 +3756,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3580	3756	"tmp.zig:1:1: error: non-extern function has no body",
3581	3757	});
3582	3758
3583		cases.add("@frame() called outside of function definition",
	3759	ctx.objErrStage1("@frame() called outside of function definition",
3584	3760	\\var handle_undef: anyframe = undefined;
3585	3761	\\var handle_dummy: anyframe = @frame();
3586	3762	\\export fn entry() bool {
...	...	@@ -3590,16 +3766,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3590	3766	"tmp.zig:2:30: error: @frame() called outside of function definition",
3591	3767	});
3592	3768
3593		cases.add("`_` is not a declarable symbol",
	3769	ctx.objErrStage1("`_` is not a declarable symbol",
3594	3770	\\export fn f1() usize {
3595	3771	\\ var _: usize = 2;
3596	3772	\\ return _;
3597	3773	\\}
3598	3774	, &[_][]const u8{
3599		"tmp.zig:2:5: error: `_` is not a declarable symbol",
	3775	"tmp.zig:2:9: error: '_' used as an identifier without @\"_\" syntax",
3600	3776	});
3601	3777
3602		cases.add("`_` should not be usable inside for",
	3778	ctx.objErrStage1("`_` should not be usable inside for",
3603	3779	\\export fn returns() void {
3604	3780	\\ for ([_]void{}) \|_, i\| {
3605	3781	\\ for ([_]void{}) \|_, j\| {
...	...	@@ -3608,10 +3784,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3608	3784	\\ }
3609	3785	\\}
3610	3786	, &[_][]const u8{
3611		"tmp.zig:4:20: error: `_` may only be used to assign things to",
	3787	"tmp.zig:4:20: error: '_' used as an identifier without @\"_\" syntax",
3612	3788	});
3613	3789
3614		cases.add("`_` should not be usable inside while",
	3790	ctx.objErrStage1("`_` should not be usable inside while",
3615	3791	\\export fn returns() void {
3616	3792	\\ while (optionalReturn()) \|_\| {
3617	3793	\\ while (optionalReturn()) \|_\| {
...	...	@@ -3623,10 +3799,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3623	3799	\\ return 1;
3624	3800	\\}
3625	3801	, &[_][]const u8{
3626		"tmp.zig:4:20: error: `_` may only be used to assign things to",
	3802	"tmp.zig:4:20: error: '_' used as an identifier without @\"_\" syntax",
3627	3803	});
3628	3804
3629		cases.add("`_` should not be usable inside while else",
	3805	ctx.objErrStage1("`_` should not be usable inside while else",
3630	3806	\\export fn returns() void {
3631	3807	\\ while (optionalReturnError()) \|_\| {
3632	3808	\\ while (optionalReturnError()) \|_\| {
...	...	@@ -3640,10 +3816,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3640	3816	\\ return error.optionalReturnError;
3641	3817	\\}
3642	3818	, &[_][]const u8{
3643		"tmp.zig:6:17: error: `_` may only be used to assign things to",
	3819	"tmp.zig:6:17: error: '_' used as an identifier without @\"_\" syntax",
3644	3820	});
3645	3821
3646		cases.add("while loop body expression ignored",
	3822	ctx.objErrStage1("while loop body expression ignored",
3647	3823	\\fn returns() usize {
3648	3824	\\ return 2;
3649	3825	\\}
...	...	@@ -3664,7 +3840,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3664	3840	"tmp.zig:13:26: error: expression value is ignored",
3665	3841	});
3666	3842
3667		cases.add("missing parameter name of generic function",
	3843	ctx.objErrStage1("missing parameter name of generic function",
3668	3844	\\fn dump(anytype) void {}
3669	3845	\\export fn entry() void {
3670	3846	\\ var a: u8 = 9;
...	...	@@ -3674,20 +3850,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3674	3850	"tmp.zig:1:9: error: missing parameter name",
3675	3851	});
3676	3852
3677		cases.add("non-inline for loop on a type that requires comptime",
	3853	ctx.objErrStage1("non-inline for loop on a type that requires comptime",
3678	3854	\\const Foo = struct {
3679	3855	\\ name: []const u8,
3680	3856	\\ T: type,
3681	3857	\\};
3682	3858	\\export fn entry() void {
3683	3859	\\ const xx: [2]Foo = undefined;
3684		\\ for (xx) \|f\| {}
	3860	\\ for (xx) \|f\| { _ = f;}
3685	3861	\\}
3686	3862	, &[_][]const u8{
3687	3863	"tmp.zig:7:5: error: values of type 'Foo' must be comptime known, but index value is runtime known",
3688	3864	});
3689	3865
3690		cases.add("generic fn as parameter without comptime keyword",
	3866	ctx.objErrStage1("generic fn as parameter without comptime keyword",
3691	3867	\\fn f(_: fn (anytype) void) void {}
3692	3868	\\fn g(_: anytype) void {}
3693	3869	\\export fn entry() void {
...	...	@@ -3697,7 +3873,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3697	3873	"tmp.zig:1:9: error: parameter of type 'fn(anytype) anytype' must be declared comptime",
3698	3874	});
3699	3875
3700		cases.add("optional pointer to void in extern struct",
	3876	ctx.objErrStage1("optional pointer to void in extern struct",
3701	3877	\\const Foo = extern struct {
3702	3878	\\ x: ?*const void,
3703	3879	\\};
...	...	@@ -3705,12 +3881,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3705	3881	\\ foo: Foo,
3706	3882	\\ y: i32,
3707	3883	\\};
3708		\\export fn entry(bar: *Bar) void {}
	3884	\\export fn entry(bar: *Bar) void {_ = bar;}
3709	3885	, &[_][]const u8{
3710	3886	"tmp.zig:2:5: error: extern structs cannot contain fields of type '?*const void'",
3711	3887	});
3712	3888
3713		cases.add("use of comptime-known undefined function value",
	3889	ctx.objErrStage1("use of comptime-known undefined function value",
3714	3890	\\const Cmd = struct {
3715	3891	\\ exec: fn () void,
3716	3892	\\};
...	...	@@ -3722,7 +3898,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3722	3898	"tmp.zig:6:12: error: use of undefined value here causes undefined behavior",
3723	3899	});
3724	3900
3725		cases.add("use of comptime-known undefined function value",
	3901	ctx.objErrStage1("use of comptime-known undefined function value",
3726	3902	\\const Cmd = struct {
3727	3903	\\ exec: fn () void,
3728	3904	\\};
...	...	@@ -3734,16 +3910,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3734	3910	"tmp.zig:6:12: error: use of undefined value here causes undefined behavior",
3735	3911	});
3736	3912
3737		cases.add("bad @alignCast at comptime",
	3913	ctx.objErrStage1("bad @alignCast at comptime",
3738	3914	\\comptime {
3739	3915	\\ const ptr = @intToPtr(*align(1) i32, 0x1);
3740	3916	\\ const aligned = @alignCast(4, ptr);
	3917	\\ _ = aligned;
3741	3918	\\}
3742	3919	, &[_][]const u8{
3743	3920	"tmp.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes",
3744	3921	});
3745	3922
3746		cases.add("@ptrToInt on *void",
	3923	ctx.objErrStage1("@ptrToInt on *void",
3747	3924	\\export fn entry() bool {
3748	3925	\\ return @ptrToInt(&{}) == @ptrToInt(&{});
3749	3926	\\}
...	...	@@ -3751,7 +3928,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3751	3928	"tmp.zig:2:23: error: pointer to size 0 type has no address",
3752	3929	});
3753	3930
3754		cases.add("@popCount - non-integer",
	3931	ctx.objErrStage1("@popCount - non-integer",
3755	3932	\\export fn entry(x: f32) u32 {
3756	3933	\\ return @popCount(f32, x);
3757	3934	\\}
...	...	@@ -3759,8 +3936,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3759	3936	"tmp.zig:2:22: error: expected integer type, found 'f32'",
3760	3937	});
3761	3938
3762		cases.addCase(x: {
3763		const tc = cases.create("wrong same named struct",
	3939	{
	3940	const case = ctx.obj("wrong same named struct", .{});
	3941	case.backend = .stage1;
	3942
	3943	case.addSourceFile("a.zig",
	3944	\\pub const Foo = struct {
	3945	\\ x: i32,
	3946	\\};
	3947	);
	3948
	3949	case.addSourceFile("b.zig",
	3950	\\pub const Foo = struct {
	3951	\\ z: f64,
	3952	\\};
	3953	);
	3954
	3955	case.addError(
3764	3956	\\const a = @import("a.zig");
3765	3957	\\const b = @import("b.zig");
3766	3958	\\
...	...	@@ -3769,30 +3961,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3769	3961	\\ bar(&a1);
3770	3962	\\}
3771	3963	\\
3772		\\fn bar(x: *b.Foo) void {}
	3964	\\fn bar(x: *b.Foo) void {_ = x;}
3773	3965	, &[_][]const u8{
3774	3966	"tmp.zig:6:10: error: expected type 'b.Foo', found 'a.Foo'",
3775	3967	"tmp.zig:6:10: note: pointer type child 'a.Foo' cannot cast into pointer type child 'b.Foo'",
3776	3968	"a.zig:1:17: note: a.Foo declared here",
3777	3969	"b.zig:1:17: note: b.Foo declared here",
3778	3970	});
	3971	}
3779	3972
3780		tc.addSourceFile("a.zig",
3781		\\pub const Foo = struct {
3782		\\ x: i32,
3783		\\};
3784		);
3785
3786		tc.addSourceFile("b.zig",
3787		\\pub const Foo = struct {
3788		\\ z: f64,
3789		\\};
3790		);
3791
3792		break :x tc;
3793		});
3794
3795		cases.add("@floatToInt comptime safety",
	3973	ctx.objErrStage1("@floatToInt comptime safety",
3796	3974	\\comptime {
3797	3975	\\ _ = @floatToInt(i8, @as(f32, -129.1));
3798	3976	\\}
...	...	@@ -3808,35 +3986,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3808	3986	"tmp.zig:8:9: error: integer value '256' cannot be stored in type 'u8'",
3809	3987	});
3810	3988
3811		cases.add("use c_void as return type of fn ptr",
	3989	ctx.objErrStage1("use c_void as return type of fn ptr",
3812	3990	\\export fn entry() void {
3813	3991	\\ const a: fn () c_void = undefined;
	3992	\\ _ = a;
3814	3993	\\}
3815	3994	, &[_][]const u8{
3816	3995	"tmp.zig:2:20: error: return type cannot be opaque",
3817	3996	});
3818	3997
3819		cases.add("use implicit casts to assign null to non-nullable pointer",
	3998	ctx.objErrStage1("use implicit casts to assign null to non-nullable pointer",
3820	3999	\\export fn entry() void {
3821	4000	\\ var x: i32 = 1234;
3822	4001	\\ var p: *i32 = &x;
3823	4002	\\ var pp: ?i32 = &p;
3824	4003	\\ pp.* = null;
3825	4004	\\ var y = p.*;
	4005	\\ _ = y;
3826	4006	\\}
3827	4007	, &[_][]const u8{
3828	4008	"tmp.zig:4:23: error: expected type '?i32', found '**i32'",
3829	4009	});
3830	4010
3831		cases.add("attempted implicit cast from T to [*]const T",
	4011	ctx.objErrStage1("attempted implicit cast from T to [*]const T",
3832	4012	\\export fn entry() void {
3833	4013	\\ const x: [*]const bool = true;
	4014	\\ _ = x;
3834	4015	\\}
3835	4016	, &[_][]const u8{
3836	4017	"tmp.zig:2:30: error: expected type '[*]const bool', found 'bool'",
3837	4018	});
3838	4019
3839		cases.add("dereference unknown length pointer",
	4020	ctx.objErrStage1("dereference unknown length pointer",
3840	4021	\\export fn entry(x: [*]i32) i32 {
3841	4022	\\ return x.*;
3842	4023	\\}
...	...	@@ -3844,7 +4025,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3844	4025	"tmp.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'",
3845	4026	});
3846	4027
3847		cases.add("field access of unknown length pointer",
	4028	ctx.objErrStage1("field access of unknown length pointer",
3848	4029	\\const Foo = extern struct {
3849	4030	\\ a: i32,
3850	4031	\\};
...	...	@@ -3856,13 +4037,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3856	4037	"tmp.zig:6:8: error: type '[*]Foo' does not support field access",
3857	4038	});
3858	4039
3859		cases.add("unknown length pointer to opaque",
	4040	ctx.objErrStage1("unknown length pointer to opaque",
3860	4041	\\export const T = [*]opaque {};
3861	4042	, &[_][]const u8{
3862	4043	"tmp.zig:1:21: error: unknown-length pointer to opaque",
3863	4044	});
3864	4045
3865		cases.add("error when evaluating return type",
	4046	ctx.objErrStage1("error when evaluating return type",
3866	4047	\\const Foo = struct {
3867	4048	\\ map: @as(i32, i32),
3868	4049	\\
...	...	@@ -3872,20 +4053,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3872	4053	\\};
3873	4054	\\export fn entry() void {
3874	4055	\\ var rule_set = try Foo.init();
	4056	\\ _ = rule_set;
3875	4057	\\}
3876	4058	, &[_][]const u8{
3877	4059	"tmp.zig:2:19: error: expected type 'i32', found 'type'",
3878	4060	});
3879	4061
3880		cases.add("slicing single-item pointer",
	4062	ctx.objErrStage1("slicing single-item pointer",
3881	4063	\\export fn entry(ptr: *i32) void {
3882	4064	\\ const slice = ptr[0..2];
	4065	\\ _ = slice;
3883	4066	\\}
3884	4067	, &[_][]const u8{
3885	4068	"tmp.zig:2:22: error: slice of single-item pointer",
3886	4069	});
3887	4070
3888		cases.add("indexing single-item pointer",
	4071	ctx.objErrStage1("indexing single-item pointer",
3889	4072	\\export fn entry(ptr: *i32) i32 {
3890	4073	\\ return ptr[1];
3891	4074	\\}
...	...	@@ -3893,12 +4076,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3893	4076	"tmp.zig:2:15: error: index of single-item pointer",
3894	4077	});
3895	4078
3896		cases.add("nested error set mismatch",
	4079	ctx.objErrStage1("nested error set mismatch",
3897	4080	\\const NextError = error{NextError};
3898	4081	\\const OtherError = error{OutOfMemory};
3899	4082	\\
3900	4083	\\export fn entry() void {
3901	4084	\\ const a: ?NextError!i32 = foo();
	4085	\\ _ = a;
3902	4086	\\}
3903	4087	\\
3904	4088	\\fn foo() ?OtherError!i32 {
...	...	@@ -3911,7 +4095,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3911	4095	"tmp.zig:2:26: note: 'error.OutOfMemory' not a member of destination error set",
3912	4096	});
3913	4097
3914		cases.add("invalid deref on switch target",
	4098	ctx.objErrStage1("invalid deref on switch target",
3915	4099	\\comptime {
3916	4100	\\ var tile = Tile.Empty;
3917	4101	\\ switch (tile.*) {
...	...	@@ -3927,13 +4111,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3927	4111	"tmp.zig:3:17: error: attempt to dereference non-pointer type 'Tile'",
3928	4112	});
3929	4113
3930		cases.add("invalid field access in comptime",
3931		\\comptime { var x = doesnt_exist.whatever; }
	4114	ctx.objErrStage1("invalid field access in comptime",
	4115	\\comptime { var x = doesnt_exist.whatever; _ = x; }
3932	4116	, &[_][]const u8{
3933	4117	"tmp.zig:1:20: error: use of undeclared identifier 'doesnt_exist'",
3934	4118	});
3935	4119
3936		cases.add("suspend inside suspend block",
	4120	ctx.objErrStage1("suspend inside suspend block",
3937	4121	\\export fn entry() void {
3938	4122	\\ _ = async foo();
3939	4123	\\}
...	...	@@ -3948,17 +4132,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3948	4132	"tmp.zig:5:5: note: other suspend block here",
3949	4133	});
3950	4134
3951		cases.add("assign inline fn to non-comptime var",
	4135	ctx.objErrStage1("assign inline fn to non-comptime var",
3952	4136	\\export fn entry() void {
3953	4137	\\ var a = b;
	4138	\\ _ = a;
3954	4139	\\}
3955	4140	\\fn b() callconv(.Inline) void { }
3956	4141	, &[_][]const u8{
3957	4142	"tmp.zig:2:5: error: functions marked inline must be stored in const or comptime var",
3958		"tmp.zig:4:1: note: declared here",
	4143	"tmp.zig:5:1: note: declared here",
3959	4144	});
3960	4145
3961		cases.add("wrong type passed to @panic",
	4146	ctx.objErrStage1("wrong type passed to @panic",
3962	4147	\\export fn entry() void {
3963	4148	\\ var e = error.Foo;
3964	4149	\\ @panic(e);
...	...	@@ -3967,7 +4152,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3967	4152	"tmp.zig:3:12: error: expected type '[]const u8', found 'error{Foo}'",
3968	4153	});
3969	4154
3970		cases.add("@tagName used on union with no associated enum tag",
	4155	ctx.objErrStage1("@tagName used on union with no associated enum tag",
3971	4156	\\const FloatInt = extern union {
3972	4157	\\ Float: f32,
3973	4158	\\ Int: i32,
...	...	@@ -3975,13 +4160,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3975	4160	\\export fn entry() void {
3976	4161	\\ var fi = FloatInt{.Float = 123.45};
3977	4162	\\ var tagName = @tagName(fi);
	4163	\\ _ = tagName;
3978	4164	\\}
3979	4165	, &[_][]const u8{
3980	4166	"tmp.zig:7:19: error: union has no associated enum",
3981	4167	"tmp.zig:1:18: note: declared here",
3982	4168	});
3983	4169
3984		cases.add("returning error from void async function",
	4170	ctx.objErrStage1("returning error from void async function",
3985	4171	\\export fn entry() void {
3986	4172	\\ _ = async amain();
3987	4173	\\}
...	...	@@ -3992,37 +4178,40 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3992	4178	"tmp.zig:5:17: error: expected type 'void', found 'error{ShouldBeCompileError}'",
3993	4179	});
3994	4180
3995		cases.add("var makes structs required to be comptime known",
	4181	ctx.objErrStage1("var makes structs required to be comptime known",
3996	4182	\\export fn entry() void {
3997	4183	\\ const S = struct{v: anytype};
3998	4184	\\ var s = S{.v=@as(i32, 10)};
	4185	\\ _ = s;
3999	4186	\\}
4000	4187	, &[_][]const u8{
4001	4188	"tmp.zig:3:4: error: variable of type 'S' must be const or comptime",
4002	4189	});
4003	4190
4004		cases.add("@ptrCast discards const qualifier",
	4191	ctx.objErrStage1("@ptrCast discards const qualifier",
4005	4192	\\export fn entry() void {
4006	4193	\\ const x: i32 = 1234;
4007	4194	\\ const y = @ptrCast(*i32, &x);
	4195	\\ _ = y;
4008	4196	\\}
4009	4197	, &[_][]const u8{
4010	4198	"tmp.zig:3:15: error: cast discards const qualifier",
4011	4199	});
4012	4200
4013		cases.add("comptime slice of undefined pointer non-zero len",
	4201	ctx.objErrStage1("comptime slice of undefined pointer non-zero len",
4014	4202	\\export fn entry() void {
4015	4203	\\ const slice = @as([*]i32, undefined)[0..1];
	4204	\\ _ = slice;
4016	4205	\\}
4017	4206	, &[_][]const u8{
4018	4207	"tmp.zig:2:41: error: non-zero length slice of undefined pointer",
4019	4208	});
4020	4209
4021		cases.add("type checking function pointers",
	4210	ctx.objErrStage1("type checking function pointers",
4022	4211	\\fn a(b: fn (*const u8) void) void {
4023	4212	\\ b('a');
4024	4213	\\}
4025		\\fn c(d: u8) void {}
	4214	\\fn c(d: u8) void {_ = d;}
4026	4215	\\export fn entry() void {
4027	4216	\\ a(c);
4028	4217	\\}
...	...	@@ -4030,7 +4219,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4030	4219	"tmp.zig:6:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'",
4031	4220	});
4032	4221
4033		cases.add("no else prong on switch on global error set",
	4222	ctx.objErrStage1("no else prong on switch on global error set",
4034	4223	\\export fn entry() void {
4035	4224	\\ foo(error.A);
4036	4225	\\}
...	...	@@ -4043,7 +4232,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4043	4232	"tmp.zig:5:5: error: else prong required when switching on type 'anyerror'",
4044	4233	});
4045	4234
4046		cases.add("error not handled in switch",
	4235	ctx.objErrStage1("error not handled in switch",
4047	4236	\\export fn entry() void {
4048	4237	\\ foo(452) catch \|err\| switch (err) {
4049	4238	\\ error.Foo => {},
...	...	@@ -4062,7 +4251,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4062	4251	"tmp.zig:2:26: error: error.Bar not handled in switch",
4063	4252	});
4064	4253
4065		cases.add("duplicate error in switch",
	4254	ctx.objErrStage1("duplicate error in switch",
4066	4255	\\export fn entry() void {
4067	4256	\\ foo(452) catch \|err\| switch (err) {
4068	4257	\\ error.Foo => {},
...	...	@@ -4080,10 +4269,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4080	4269	\\}
4081	4270	, &[_][]const u8{
4082	4271	"tmp.zig:5:14: error: duplicate switch value: '@typeInfo(@typeInfo(@TypeOf(foo)).Fn.return_type.?).ErrorUnion.error_set.Foo'",
4083		"tmp.zig:3:14: note: other value is here",
	4272	"tmp.zig:3:14: note: other value here",
4084	4273	});
4085	4274
4086		cases.add("invalid cast from integral type to enum",
	4275	ctx.objErrStage1("invalid cast from integral type to enum",
4087	4276	\\const E = enum(usize) { One, Two };
4088	4277	\\
4089	4278	\\export fn entry() void {
...	...	@@ -4099,7 +4288,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4099	4288	"tmp.zig:9:10: error: expected type 'usize', found 'E'",
4100	4289	});
4101	4290
4102		cases.add("range operator in switch used on error set",
	4291	ctx.objErrStage1("range operator in switch used on error set",
4103	4292	\\export fn entry() void {
4104	4293	\\ try foo(452) catch \|err\| switch (err) {
4105	4294	\\ error.A ... error.B => {},
...	...	@@ -4117,33 +4306,35 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4117	4306	"tmp.zig:3:17: error: operator not allowed for errors",
4118	4307	});
4119	4308
4120		cases.add("inferring error set of function pointer",
	4309	ctx.objErrStage1("inferring error set of function pointer",
4121	4310	\\comptime {
4122	4311	\\ const z: ?fn()!void = null;
4123	4312	\\}
4124	4313	, &[_][]const u8{
4125		"tmp.zig:2:15: error: inferring error set of return type valid only for function definitions",
	4314	"tmp.zig:2:19: error: function prototype may not have inferred error set",
4126	4315	});
4127	4316
4128		cases.add("access non-existent member of error set",
	4317	ctx.objErrStage1("access non-existent member of error set",
4129	4318	\\const Foo = error{A};
4130	4319	\\comptime {
4131	4320	\\ const z = Foo.Bar;
	4321	\\ _ = z;
4132	4322	\\}
4133	4323	, &[_][]const u8{
4134	4324	"tmp.zig:3:18: error: no error named 'Bar' in 'Foo'",
4135	4325	});
4136	4326
4137		cases.add("error union operator with non error set LHS",
	4327	ctx.objErrStage1("error union operator with non error set LHS",
4138	4328	\\comptime {
4139	4329	\\ const z = i32!i32;
4140	4330	\\ var x: z = undefined;
	4331	\\ _ = x;
4141	4332	\\}
4142	4333	, &[_][]const u8{
4143	4334	"tmp.zig:2:15: error: expected error set type, found type 'i32'",
4144	4335	});
4145	4336
4146		cases.add("error equality but sets have no common members",
	4337	ctx.objErrStage1("error equality but sets have no common members",
4147	4338	\\const Set1 = error{A, C};
4148	4339	\\const Set2 = error{B, D};
4149	4340	\\export fn entry() void {
...	...	@@ -4158,29 +4349,32 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4158	4349	"tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors",
4159	4350	});
4160	4351
4161		cases.add("only equality binary operator allowed for error sets",
	4352	ctx.objErrStage1("only equality binary operator allowed for error sets",
4162	4353	\\comptime {
4163	4354	\\ const z = error.A > error.B;
	4355	\\ _ = z;
4164	4356	\\}
4165	4357	, &[_][]const u8{
4166	4358	"tmp.zig:2:23: error: operator not allowed for errors",
4167	4359	});
4168	4360
4169		cases.add("explicit error set cast known at comptime violates error sets",
	4361	ctx.objErrStage1("explicit error set cast known at comptime violates error sets",
4170	4362	\\const Set1 = error {A, B};
4171	4363	\\const Set2 = error {A, C};
4172	4364	\\comptime {
4173	4365	\\ var x = Set1.B;
4174	4366	\\ var y = @errSetCast(Set2, x);
	4367	\\ _ = y;
4175	4368	\\}
4176	4369	, &[_][]const u8{
4177	4370	"tmp.zig:5:13: error: error.B not a member of error set 'Set2'",
4178	4371	});
4179	4372
4180		cases.add("cast error union of global error set to error union of smaller error set",
	4373	ctx.objErrStage1("cast error union of global error set to error union of smaller error set",
4181	4374	\\const SmallErrorSet = error{A};
4182	4375	\\export fn entry() void {
4183	4376	\\ var x: SmallErrorSet!i32 = foo();
	4377	\\ _ = x;
4184	4378	\\}
4185	4379	\\fn foo() anyerror!i32 {
4186	4380	\\ return error.B;
...	...	@@ -4191,10 +4385,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4191	4385	"tmp.zig:3:35: note: cannot cast global error set into smaller set",
4192	4386	});
4193	4387
4194		cases.add("cast global error set to error set",
	4388	ctx.objErrStage1("cast global error set to error set",
4195	4389	\\const SmallErrorSet = error{A};
4196	4390	\\export fn entry() void {
4197	4391	\\ var x: SmallErrorSet = foo();
	4392	\\ _ = x;
4198	4393	\\}
4199	4394	\\fn foo() anyerror {
4200	4395	\\ return error.B;
...	...	@@ -4203,7 +4398,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4203	4398	"tmp.zig:3:31: error: expected type 'SmallErrorSet', found 'anyerror'",
4204	4399	"tmp.zig:3:31: note: cannot cast global error set into smaller set",
4205	4400	});
4206		cases.add("recursive inferred error set",
	4401	ctx.objErrStage1("recursive inferred error set",
4207	4402	\\export fn entry() void {
4208	4403	\\ foo() catch unreachable;
4209	4404	\\}
...	...	@@ -4214,7 +4409,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4214	4409	"tmp.zig:5:5: error: cannot resolve inferred error set '@typeInfo(@typeInfo(@TypeOf(foo)).Fn.return_type.?).ErrorUnion.error_set': function 'foo' not fully analyzed yet",
4215	4410	});
4216	4411
4217		cases.add("implicit cast of error set not a subset",
	4412	ctx.objErrStage1("implicit cast of error set not a subset",
4218	4413	\\const Set1 = error{A, B};
4219	4414	\\const Set2 = error{A, C};
4220	4415	\\export fn entry() void {
...	...	@@ -4222,13 +4417,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4222	4417	\\}
4223	4418	\\fn foo(set1: Set1) void {
4224	4419	\\ var x: Set2 = set1;
	4420	\\ _ = x;
4225	4421	\\}
4226	4422	, &[_][]const u8{
4227	4423	"tmp.zig:7:19: error: expected type 'Set2', found 'Set1'",
4228	4424	"tmp.zig:1:23: note: 'error.B' not a member of destination error set",
4229	4425	});
4230	4426
4231		cases.add("int to err global invalid number",
	4427	ctx.objErrStage1("int to err global invalid number",
4232	4428	\\const Set1 = error{
4233	4429	\\ A,
4234	4430	\\ B,
...	...	@@ -4236,12 +4432,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4236	4432	\\comptime {
4237	4433	\\ var x: u16 = 3;
4238	4434	\\ var y = @intToError(x);
	4435	\\ _ = y;
4239	4436	\\}
4240	4437	, &[_][]const u8{
4241	4438	"tmp.zig:7:13: error: integer value 3 represents no error",
4242	4439	});
4243	4440
4244		cases.add("int to err non global invalid number",
	4441	ctx.objErrStage1("int to err non global invalid number",
4245	4442	\\const Set1 = error{
4246	4443	\\ A,
4247	4444	\\ B,
...	...	@@ -4253,68 +4450,74 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4253	4450	\\comptime {
4254	4451	\\ var x = @errorToInt(Set1.B);
4255	4452	\\ var y = @errSetCast(Set2, @intToError(x));
	4453	\\ _ = y;
4256	4454	\\}
4257	4455	, &[_][]const u8{
4258	4456	"tmp.zig:11:13: error: error.B not a member of error set 'Set2'",
4259	4457	});
4260	4458
4261		cases.add("duplicate error value in error set",
	4459	ctx.objErrStage1("duplicate error value in error set",
4262	4460	\\const Foo = error {
4263	4461	\\ Bar,
4264	4462	\\ Bar,
4265	4463	\\};
4266	4464	\\export fn entry() void {
4267	4465	\\ const a: Foo = undefined;
	4466	\\ _ = a;
4268	4467	\\}
4269	4468	, &[_][]const u8{
4270	4469	"tmp.zig:3:5: error: duplicate error: 'Bar'",
4271	4470	"tmp.zig:2:5: note: other error here",
4272	4471	});
4273	4472
4274		cases.add("cast negative integer literal to usize",
	4473	ctx.objErrStage1("cast negative integer literal to usize",
4275	4474	\\export fn entry() void {
4276	4475	\\ const x = @as(usize, -10);
	4476	\\ _ = x;
4277	4477	\\}
4278	4478	, &[_][]const u8{
4279	4479	"tmp.zig:2:26: error: cannot cast negative value -10 to unsigned integer type 'usize'",
4280	4480	});
4281	4481
4282		cases.add("use invalid number literal as array index",
	4482	ctx.objErrStage1("use invalid number literal as array index",
4283	4483	\\var v = 25;
4284	4484	\\export fn entry() void {
4285	4485	\\ var arr: [v]u8 = undefined;
	4486	\\ _ = arr;
4286	4487	\\}
4287	4488	, &[_][]const u8{
4288	4489	"tmp.zig:1:1: error: unable to infer variable type",
4289	4490	});
4290	4491
4291		cases.add("duplicate struct field",
	4492	ctx.objErrStage1("duplicate struct field",
4292	4493	\\const Foo = struct {
4293	4494	\\ Bar: i32,
4294	4495	\\ Bar: usize,
4295	4496	\\};
4296	4497	\\export fn entry() void {
4297	4498	\\ const a: Foo = undefined;
	4499	\\ _ = a;
4298	4500	\\}
4299	4501	, &[_][]const u8{
4300	4502	"tmp.zig:3:5: error: duplicate struct field: 'Bar'",
4301	4503	"tmp.zig:2:5: note: other field here",
4302	4504	});
4303	4505
4304		cases.add("duplicate union field",
	4506	ctx.objErrStage1("duplicate union field",
4305	4507	\\const Foo = union {
4306	4508	\\ Bar: i32,
4307	4509	\\ Bar: usize,
4308	4510	\\};
4309	4511	\\export fn entry() void {
4310	4512	\\ const a: Foo = undefined;
	4513	\\ _ = a;
4311	4514	\\}
4312	4515	, &[_][]const u8{
4313	4516	"tmp.zig:3:5: error: duplicate union field: 'Bar'",
4314	4517	"tmp.zig:2:5: note: other field here",
4315	4518	});
4316	4519
4317		cases.add("duplicate enum field",
	4520	ctx.objErrStage1("duplicate enum field",
4318	4521	\\const Foo = enum {
4319	4522	\\ Bar,
4320	4523	\\ Bar,
...	...	@@ -4322,13 +4525,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4322	4525	\\
4323	4526	\\export fn entry() void {
4324	4527	\\ const a: Foo = undefined;
	4528	\\ _ = a;
4325	4529	\\}
4326	4530	, &[_][]const u8{
4327	4531	"tmp.zig:3:5: error: duplicate enum field: 'Bar'",
4328	4532	"tmp.zig:2:5: note: other field here",
4329	4533	});
4330	4534
4331		cases.add("calling function with naked calling convention",
	4535	ctx.objErrStage1("calling function with naked calling convention",
4332	4536	\\export fn entry() void {
4333	4537	\\ foo();
4334	4538	\\}
...	...	@@ -4338,42 +4542,42 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4338	4542	"tmp.zig:4:1: note: declared here",
4339	4543	});
4340	4544
4341		cases.add("function with invalid return type",
	4545	ctx.objErrStage1("function with invalid return type",
4342	4546	\\export fn foo() boid {}
4343	4547	, &[_][]const u8{
4344	4548	"tmp.zig:1:17: error: use of undeclared identifier 'boid'",
4345	4549	});
4346	4550
4347		cases.add("function with non-extern non-packed enum parameter",
	4551	ctx.objErrStage1("function with non-extern non-packed enum parameter",
4348	4552	\\const Foo = enum { A, B, C };
4349		\\export fn entry(foo: Foo) void { }
	4553	\\export fn entry(foo: Foo) void { _ = foo; }
4350	4554	, &[_][]const u8{
4351	4555	"tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
4352	4556	});
4353	4557
4354		cases.add("function with non-extern non-packed struct parameter",
	4558	ctx.objErrStage1("function with non-extern non-packed struct parameter",
4355	4559	\\const Foo = struct {
4356	4560	\\ A: i32,
4357	4561	\\ B: f32,
4358	4562	\\ C: bool,
4359	4563	\\};
4360		\\export fn entry(foo: Foo) void { }
	4564	\\export fn entry(foo: Foo) void { _ = foo; }
4361	4565	, &[_][]const u8{
4362	4566	"tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
4363	4567	});
4364	4568
4365		cases.add("function with non-extern non-packed union parameter",
	4569	ctx.objErrStage1("function with non-extern non-packed union parameter",
4366	4570	\\const Foo = union {
4367	4571	\\ A: i32,
4368	4572	\\ B: f32,
4369	4573	\\ C: bool,
4370	4574	\\};
4371		\\export fn entry(foo: Foo) void { }
	4575	\\export fn entry(foo: Foo) void { _ = foo; }
4372	4576	, &[_][]const u8{
4373	4577	"tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
4374	4578	});
4375	4579
4376		cases.add("switch on enum with 1 field with no prongs",
	4580	ctx.objErrStage1("switch on enum with 1 field with no prongs",
4377	4581	\\const Foo = enum { M };
4378	4582	\\
4379	4583	\\export fn entry() void {
...	...	@@ -4384,15 +4588,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4384	4588	"tmp.zig:5:5: error: enumeration value 'Foo.M' not handled in switch",
4385	4589	});
4386	4590
4387		cases.add("shift by negative comptime integer",
	4591	ctx.objErrStage1("shift by negative comptime integer",
4388	4592	\\comptime {
4389	4593	\\ var a = 1 >> -1;
	4594	\\ _ = a;
4390	4595	\\}
4391	4596	, &[_][]const u8{
4392	4597	"tmp.zig:2:18: error: shift by negative value -1",
4393	4598	});
4394	4599
4395		cases.add("@panic called at compile time",
	4600	ctx.objErrStage1("@panic called at compile time",
4396	4601	\\export fn entry() void {
4397	4602	\\ comptime {
4398	4603	\\ @panic("aoeu",);
...	...	@@ -4402,20 +4607,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4402	4607	"tmp.zig:3:9: error: encountered @panic at compile-time",
4403	4608	});
4404	4609
4405		cases.add("wrong return type for main",
	4610	ctx.objErrStage1("wrong return type for main",
4406	4611	\\pub fn main() f32 { }
4407	4612	, &[_][]const u8{
4408	4613	"error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'",
4409	4614	});
4410	4615
4411		cases.add("double ?? on main return value",
	4616	ctx.objErrStage1("double ?? on main return value",
4412	4617	\\pub fn main() ??void {
4413	4618	\\}
4414	4619	, &[_][]const u8{
4415	4620	"error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'",
4416	4621	});
4417	4622
4418		cases.add("bad identifier in function with struct defined inside function which references local const",
	4623	ctx.objErrStage1("bad identifier in function with struct defined inside function which references local const",
4419	4624	\\export fn entry() void {
4420	4625	\\ const BlockKind = u32;
4421	4626	\\
...	...	@@ -4424,12 +4629,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4424	4629	\\ };
4425	4630	\\
4426	4631	\\ bogus;
	4632	\\
	4633	\\ _ = Block;
4427	4634	\\}
4428	4635	, &[_][]const u8{
4429	4636	"tmp.zig:8:5: error: use of undeclared identifier 'bogus'",
4430	4637	});
4431	4638
4432		cases.add("labeled break not found",
	4639	ctx.objErrStage1("labeled break not found",
4433	4640	\\export fn entry() void {
4434	4641	\\ blah: while (true) {
4435	4642	\\ while (true) {
...	...	@@ -4438,10 +4645,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4438	4645	\\ }
4439	4646	\\}
4440	4647	, &[_][]const u8{
4441		"tmp.zig:4:13: error: label not found: 'outer'",
	4648	"tmp.zig:4:20: error: label not found: 'outer'",
4442	4649	});
4443	4650
4444		cases.add("labeled continue not found",
	4651	ctx.objErrStage1("labeled continue not found",
4445	4652	\\export fn entry() void {
4446	4653	\\ var i: usize = 0;
4447	4654	\\ blah: while (i < 10) : (i += 1) {
...	...	@@ -4451,17 +4658,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4451	4658	\\ }
4452	4659	\\}
4453	4660	, &[_][]const u8{
4454		"tmp.zig:5:13: error: labeled loop not found: 'outer'",
	4661	"tmp.zig:5:23: error: label not found: 'outer'",
4455	4662	});
4456	4663
4457		cases.add("attempt to use 0 bit type in extern fn",
	4664	ctx.objErrStage1("attempt to use 0 bit type in extern fn",
4458	4665	\\extern fn foo(ptr: fn(*void) callconv(.C) void) void;
4459	4666	\\
4460	4667	\\export fn entry() void {
4461	4668	\\ foo(bar);
4462	4669	\\}
4463	4670	\\
4464		\\fn bar(x: *void) callconv(.C) void { }
	4671	\\fn bar(x: *void) callconv(.C) void { _ = x; }
4465	4672	\\export fn entry2() void {
4466	4673	\\ bar(&{});
4467	4674	\\}
...	...	@@ -4470,7 +4677,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4470	4677	"tmp.zig:7:11: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'",
4471	4678	});
4472	4679
4473		cases.add("implicit semicolon - block statement",
	4680	ctx.objErrStage1("implicit semicolon - block statement",
4474	4681	\\export fn entry() void {
4475	4682	\\ {}
4476	4683	\\ var good = {};
...	...	@@ -4478,10 +4685,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4478	4685	\\ var bad = {};
4479	4686	\\}
4480	4687	, &[_][]const u8{
4481		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4688	"tmp.zig:5:5: error: expected ';', found 'var'",
4482	4689	});
4483	4690
4484		cases.add("implicit semicolon - block expr",
	4691	ctx.objErrStage1("implicit semicolon - block expr",
4485	4692	\\export fn entry() void {
4486	4693	\\ _ = {};
4487	4694	\\ var good = {};
...	...	@@ -4489,10 +4696,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4489	4696	\\ var bad = {};
4490	4697	\\}
4491	4698	, &[_][]const u8{
4492		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4699	"tmp.zig:5:5: error: expected ';', found 'var'",
4493	4700	});
4494	4701
4495		cases.add("implicit semicolon - comptime statement",
	4702	ctx.objErrStage1("implicit semicolon - comptime statement",
4496	4703	\\export fn entry() void {
4497	4704	\\ comptime {}
4498	4705	\\ var good = {};
...	...	@@ -4500,10 +4707,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4500	4707	\\ var bad = {};
4501	4708	\\}
4502	4709	, &[_][]const u8{
4503		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4710	"tmp.zig:5:5: error: expected ';', found 'var'",
4504	4711	});
4505	4712
4506		cases.add("implicit semicolon - comptime expression",
	4713	ctx.objErrStage1("implicit semicolon - comptime expression",
4507	4714	\\export fn entry() void {
4508	4715	\\ _ = comptime {};
4509	4716	\\ var good = {};
...	...	@@ -4511,10 +4718,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4511	4718	\\ var bad = {};
4512	4719	\\}
4513	4720	, &[_][]const u8{
4514		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4721	"tmp.zig:5:5: error: expected ';', found 'var'",
4515	4722	});
4516	4723
4517		cases.add("implicit semicolon - defer",
	4724	ctx.objErrStage1("implicit semicolon - defer",
4518	4725	\\export fn entry() void {
4519	4726	\\ defer {}
4520	4727	\\ var good = {};
...	...	@@ -4522,10 +4729,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4522	4729	\\ var bad = {};
4523	4730	\\}
4524	4731	, &[_][]const u8{
4525		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4732	"tmp.zig:5:5: error: expected ';', found 'var'",
4526	4733	});
4527	4734
4528		cases.add("implicit semicolon - if statement",
	4735	ctx.objErrStage1("implicit semicolon - if statement",
4529	4736	\\export fn entry() void {
4530	4737	\\ if(true) {}
4531	4738	\\ var good = {};
...	...	@@ -4533,10 +4740,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4533	4740	\\ var bad = {};
4534	4741	\\}
4535	4742	, &[_][]const u8{
4536		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4743	"tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
4537	4744	});
4538	4745
4539		cases.add("implicit semicolon - if expression",
	4746	ctx.objErrStage1("implicit semicolon - if expression",
4540	4747	\\export fn entry() void {
4541	4748	\\ _ = if(true) {};
4542	4749	\\ var good = {};
...	...	@@ -4544,10 +4751,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4544	4751	\\ var bad = {};
4545	4752	\\}
4546	4753	, &[_][]const u8{
4547		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4754	"tmp.zig:5:5: error: expected ';', found 'var'",
4548	4755	});
4549	4756
4550		cases.add("implicit semicolon - if-else statement",
	4757	ctx.objErrStage1("implicit semicolon - if-else statement",
4551	4758	\\export fn entry() void {
4552	4759	\\ if(true) {} else {}
4553	4760	\\ var good = {};
...	...	@@ -4555,10 +4762,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4555	4762	\\ var bad = {};
4556	4763	\\}
4557	4764	, &[_][]const u8{
4558		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4765	"tmp.zig:5:5: error: expected ';', found 'var'",
4559	4766	});
4560	4767
4561		cases.add("implicit semicolon - if-else expression",
	4768	ctx.objErrStage1("implicit semicolon - if-else expression",
4562	4769	\\export fn entry() void {
4563	4770	\\ _ = if(true) {} else {};
4564	4771	\\ var good = {};
...	...	@@ -4566,10 +4773,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4566	4773	\\ var bad = {};
4567	4774	\\}
4568	4775	, &[_][]const u8{
4569		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4776	"tmp.zig:5:5: error: expected ';', found 'var'",
4570	4777	});
4571	4778
4572		cases.add("implicit semicolon - if-else-if statement",
	4779	ctx.objErrStage1("implicit semicolon - if-else-if statement",
4573	4780	\\export fn entry() void {
4574	4781	\\ if(true) {} else if(true) {}
4575	4782	\\ var good = {};
...	...	@@ -4577,10 +4784,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4577	4784	\\ var bad = {};
4578	4785	\\}
4579	4786	, &[_][]const u8{
4580		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4787	"tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
4581	4788	});
4582	4789
4583		cases.add("implicit semicolon - if-else-if expression",
	4790	ctx.objErrStage1("implicit semicolon - if-else-if expression",
4584	4791	\\export fn entry() void {
4585	4792	\\ _ = if(true) {} else if(true) {};
4586	4793	\\ var good = {};
...	...	@@ -4588,10 +4795,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4588	4795	\\ var bad = {};
4589	4796	\\}
4590	4797	, &[_][]const u8{
4591		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4798	"tmp.zig:5:5: error: expected ';', found 'var'",
4592	4799	});
4593	4800
4594		cases.add("implicit semicolon - if-else-if-else statement",
	4801	ctx.objErrStage1("implicit semicolon - if-else-if-else statement",
4595	4802	\\export fn entry() void {
4596	4803	\\ if(true) {} else if(true) {} else {}
4597	4804	\\ var good = {};
...	...	@@ -4599,10 +4806,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4599	4806	\\ var bad = {};
4600	4807	\\}
4601	4808	, &[_][]const u8{
4602		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4809	"tmp.zig:5:5: error: expected ';', found 'var'",
4603	4810	});
4604	4811
4605		cases.add("implicit semicolon - if-else-if-else expression",
	4812	ctx.objErrStage1("implicit semicolon - if-else-if-else expression",
4606	4813	\\export fn entry() void {
4607	4814	\\ _ = if(true) {} else if(true) {} else {};
4608	4815	\\ var good = {};
...	...	@@ -4610,10 +4817,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4610	4817	\\ var bad = {};
4611	4818	\\}
4612	4819	, &[_][]const u8{
4613		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4820	"tmp.zig:5:5: error: expected ';', found 'var'",
4614	4821	});
4615	4822
4616		cases.add("implicit semicolon - test statement",
	4823	ctx.objErrStage1("implicit semicolon - test statement",
4617	4824	\\export fn entry() void {
4618	4825	\\ if (foo()) \|_\| {}
4619	4826	\\ var good = {};
...	...	@@ -4621,10 +4828,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4621	4828	\\ var bad = {};
4622	4829	\\}
4623	4830	, &[_][]const u8{
4624		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4831	"tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
4625	4832	});
4626	4833
4627		cases.add("implicit semicolon - test expression",
	4834	ctx.objErrStage1("implicit semicolon - test expression",
4628	4835	\\export fn entry() void {
4629	4836	\\ _ = if (foo()) \|_\| {};
4630	4837	\\ var good = {};
...	...	@@ -4632,10 +4839,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4632	4839	\\ var bad = {};
4633	4840	\\}
4634	4841	, &[_][]const u8{
4635		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4842	"tmp.zig:5:5: error: expected ';', found 'var'",
4636	4843	});
4637	4844
4638		cases.add("implicit semicolon - while statement",
	4845	ctx.objErrStage1("implicit semicolon - while statement",
4639	4846	\\export fn entry() void {
4640	4847	\\ while(true) {}
4641	4848	\\ var good = {};
...	...	@@ -4643,10 +4850,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4643	4850	\\ var bad = {};
4644	4851	\\}
4645	4852	, &[_][]const u8{
4646		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4853	"tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
4647	4854	});
4648	4855
4649		cases.add("implicit semicolon - while expression",
	4856	ctx.objErrStage1("implicit semicolon - while expression",
4650	4857	\\export fn entry() void {
4651	4858	\\ _ = while(true) {};
4652	4859	\\ var good = {};
...	...	@@ -4654,10 +4861,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4654	4861	\\ var bad = {};
4655	4862	\\}
4656	4863	, &[_][]const u8{
4657		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4864	"tmp.zig:5:5: error: expected ';', found 'var'",
4658	4865	});
4659	4866
4660		cases.add("implicit semicolon - while-continue statement",
	4867	ctx.objErrStage1("implicit semicolon - while-continue statement",
4661	4868	\\export fn entry() void {
4662	4869	\\ while(true):({}) {}
4663	4870	\\ var good = {};
...	...	@@ -4665,10 +4872,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4665	4872	\\ var bad = {};
4666	4873	\\}
4667	4874	, &[_][]const u8{
4668		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4875	"tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
4669	4876	});
4670	4877
4671		cases.add("implicit semicolon - while-continue expression",
	4878	ctx.objErrStage1("implicit semicolon - while-continue expression",
4672	4879	\\export fn entry() void {
4673	4880	\\ _ = while(true):({}) {};
4674	4881	\\ var good = {};
...	...	@@ -4676,10 +4883,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4676	4883	\\ var bad = {};
4677	4884	\\}
4678	4885	, &[_][]const u8{
4679		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4886	"tmp.zig:5:5: error: expected ';', found 'var'",
4680	4887	});
4681	4888
4682		cases.add("implicit semicolon - for statement",
	4889	ctx.objErrStage1("implicit semicolon - for statement",
4683	4890	\\export fn entry() void {
4684	4891	\\ for(foo()) \|_\| {}
4685	4892	\\ var good = {};
...	...	@@ -4687,10 +4894,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4687	4894	\\ var bad = {};
4688	4895	\\}
4689	4896	, &[_][]const u8{
4690		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4897	"tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
4691	4898	});
4692	4899
4693		cases.add("implicit semicolon - for expression",
	4900	ctx.objErrStage1("implicit semicolon - for expression",
4694	4901	\\export fn entry() void {
4695	4902	\\ _ = for(foo()) \|_\| {};
4696	4903	\\ var good = {};
...	...	@@ -4698,32 +4905,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4698	4905	\\ var bad = {};
4699	4906	\\}
4700	4907	, &[_][]const u8{
4701		"tmp.zig:5:5: error: expected token ';', found 'var'",
	4908	"tmp.zig:5:5: error: expected ';', found 'var'",
4702	4909	});
4703	4910
4704		cases.add("multiple function definitions",
	4911	ctx.objErrStage1("multiple function definitions",
4705	4912	\\fn a() void {}
4706	4913	\\fn a() void {}
4707	4914	\\export fn entry() void { a(); }
4708	4915	, &[_][]const u8{
4709		"tmp.zig:2:1: error: redefinition of 'a'",
	4916	"tmp.zig:2:1: error: redeclaration of 'a'",
	4917	"tmp.zig:1:1: note: other declaration here",
4710	4918	});
4711	4919
4712		cases.add("unreachable with return",
	4920	ctx.objErrStage1("unreachable with return",
4713	4921	\\fn a() noreturn {return;}
4714	4922	\\export fn entry() void { a(); }
4715	4923	, &[_][]const u8{
4716	4924	"tmp.zig:1:18: error: expected type 'noreturn', found 'void'",
4717	4925	});
4718	4926
4719		cases.add("control reaches end of non-void function",
	4927	ctx.objErrStage1("control reaches end of non-void function",
4720	4928	\\fn a() i32 {}
4721	4929	\\export fn entry() void { _ = a(); }
4722	4930	, &[_][]const u8{
4723	4931	"tmp.zig:1:12: error: expected type 'i32', found 'void'",
4724	4932	});
4725	4933
4726		cases.add("undefined function call",
	4934	ctx.objErrStage1("undefined function call",
4727	4935	\\export fn a() void {
4728	4936	\\ b();
4729	4937	\\}
...	...	@@ -4731,30 +4939,30 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4731	4939	"tmp.zig:2:5: error: use of undeclared identifier 'b'",
4732	4940	});
4733	4941
4734		cases.add("wrong number of arguments",
	4942	ctx.objErrStage1("wrong number of arguments",
4735	4943	\\export fn a() void {
4736		\\ b(1);
	4944	\\ c(1);
4737	4945	\\}
4738		\\fn b(a: i32, b: i32, c: i32) void { }
	4946	\\fn c(d: i32, e: i32, f: i32) void { _ = d; _ = e; _ = f; }
4739	4947	, &[_][]const u8{
4740	4948	"tmp.zig:2:6: error: expected 3 argument(s), found 1",
4741	4949	});
4742	4950
4743		cases.add("invalid type",
	4951	ctx.objErrStage1("invalid type",
4744	4952	\\fn a() bogus {}
4745	4953	\\export fn entry() void { _ = a(); }
4746	4954	, &[_][]const u8{
4747	4955	"tmp.zig:1:8: error: use of undeclared identifier 'bogus'",
4748	4956	});
4749	4957
4750		cases.add("pointer to noreturn",
	4958	ctx.objErrStage1("pointer to noreturn",
4751	4959	\\fn a() *noreturn {}
4752	4960	\\export fn entry() void { _ = a(); }
4753	4961	, &[_][]const u8{
4754	4962	"tmp.zig:1:9: error: pointer to noreturn not allowed",
4755	4963	});
4756	4964
4757		cases.add("unreachable code",
	4965	ctx.objErrStage1("unreachable code",
4758	4966	\\export fn a() void {
4759	4967	\\ return;
4760	4968	\\ b();
...	...	@@ -4762,17 +4970,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4762	4970	\\
4763	4971	\\fn b() void {}
4764	4972	, &[_][]const u8{
4765		"tmp.zig:3:5: error: unreachable code",
	4973	"tmp.zig:3:6: error: unreachable code",
	4974	"tmp.zig:2:5: note: control flow is diverted here",
4766	4975	});
4767	4976
4768		cases.add("bad import",
	4977	ctx.objErrStage1("bad import",
4769	4978	\\const bogus = @import("bogus-does-not-exist.zig",);
4770		\\export fn entry() void { bogus.bogo(); }
4771	4979	, &[_][]const u8{
4772		"tmp.zig:1:15: error: unable to find 'bogus-does-not-exist.zig'",
	4980	"tmp.zig:1:23: error: unable to load '${DIR}bogus-does-not-exist.zig': FileNotFound",
4773	4981	});
4774	4982
4775		cases.add("undeclared identifier",
	4983	ctx.objErrStage1("undeclared identifier",
4776	4984	\\export fn a() void {
4777	4985	\\ return
4778	4986	\\ b +
...	...	@@ -4782,33 +4990,36 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4782	4990	"tmp.zig:3:5: error: use of undeclared identifier 'b'",
4783	4991	});
4784	4992
4785		cases.add("parameter redeclaration",
	4993	ctx.objErrStage1("parameter redeclaration",
4786	4994	\\fn f(a : i32, a : i32) void {
4787	4995	\\}
4788	4996	\\export fn entry() void { f(1, 2); }
4789	4997	, &[_][]const u8{
4790		"tmp.zig:1:15: error: redeclaration of variable 'a'",
	4998	"tmp.zig:1:15: error: redeclaration of function parameter 'a'",
	4999	"tmp.zig:1:6: note: previous declaration here",
4791	5000	});
4792	5001
4793		cases.add("local variable redeclaration",
	5002	ctx.objErrStage1("local variable redeclaration",
4794	5003	\\export fn f() void {
4795	5004	\\ const a : i32 = 0;
4796		\\ const a = 0;
	5005	\\ var a = 0;
4797	5006	\\}
4798	5007	, &[_][]const u8{
4799		"tmp.zig:3:5: error: redeclaration of variable 'a'",
	5008	"tmp.zig:3:9: error: redeclaration of local constant 'a'",
	5009	"tmp.zig:2:11: note: previous declaration here",
4800	5010	});
4801	5011
4802		cases.add("local variable redeclares parameter",
	5012	ctx.objErrStage1("local variable redeclares parameter",
4803	5013	\\fn f(a : i32) void {
4804	5014	\\ const a = 0;
4805	5015	\\}
4806	5016	\\export fn entry() void { f(1); }
4807	5017	, &[_][]const u8{
4808		"tmp.zig:2:5: error: redeclaration of variable 'a'",
	5018	"tmp.zig:2:11: error: redeclaration of function parameter 'a'",
	5019	"tmp.zig:1:6: note: previous declaration here",
4809	5020	});
4810	5021
4811		cases.add("variable has wrong type",
	5022	ctx.objErrStage1("variable has wrong type",
4812	5023	\\export fn f() i32 {
4813	5024	\\ const a = "a";
4814	5025	\\ return a;
...	...	@@ -4817,7 +5028,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4817	5028	"tmp.zig:3:12: error: expected type 'i32', found '*const [1:0]u8'",
4818	5029	});
4819	5030
4820		cases.add("if condition is bool, not int",
	5031	ctx.objErrStage1("if condition is bool, not int",
4821	5032	\\export fn f() void {
4822	5033	\\ if (0) {}
4823	5034	\\}
...	...	@@ -4825,30 +5036,32 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4825	5036	"tmp.zig:2:9: error: expected type 'bool', found 'comptime_int'",
4826	5037	});
4827	5038
4828		cases.add("assign unreachable",
	5039	ctx.objErrStage1("assign unreachable",
4829	5040	\\export fn f() void {
4830	5041	\\ const a = return;
4831	5042	\\}
4832	5043	, &[_][]const u8{
4833	5044	"tmp.zig:2:5: error: unreachable code",
	5045	"tmp.zig:2:15: note: control flow is diverted here",
4834	5046	});
4835	5047
4836		cases.add("unreachable variable",
	5048	ctx.objErrStage1("unreachable variable",
4837	5049	\\export fn f() void {
4838	5050	\\ const a: noreturn = {};
	5051	\\ _ = a;
4839	5052	\\}
4840	5053	, &[_][]const u8{
4841	5054	"tmp.zig:2:25: error: expected type 'noreturn', found 'void'",
4842	5055	});
4843	5056
4844		cases.add("unreachable parameter",
4845		\\fn f(a: noreturn) void {}
	5057	ctx.objErrStage1("unreachable parameter",
	5058	\\fn f(a: noreturn) void { _ = a; }
4846	5059	\\export fn entry() void { f(); }
4847	5060	, &[_][]const u8{
4848	5061	"tmp.zig:1:9: error: parameter of type 'noreturn' not allowed",
4849	5062	});
4850	5063
4851		cases.add("assign to constant variable",
	5064	ctx.objErrStage1("assign to constant variable",
4852	5065	\\export fn f() void {
4853	5066	\\ const a = 3;
4854	5067	\\ a = 4;
...	...	@@ -4857,7 +5070,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4857	5070	"tmp.zig:3:9: error: cannot assign to constant",
4858	5071	});
4859	5072
4860		cases.add("use of undeclared identifier",
	5073	ctx.objErrStage1("use of undeclared identifier",
4861	5074	\\export fn f() void {
4862	5075	\\ b = 3;
4863	5076	\\}
...	...	@@ -4865,15 +5078,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4865	5078	"tmp.zig:2:5: error: use of undeclared identifier 'b'",
4866	5079	});
4867	5080
4868		cases.add("const is a statement, not an expression",
	5081	ctx.objErrStage1("const is a statement, not an expression",
4869	5082	\\export fn f() void {
4870	5083	\\ (const a = 0);
4871	5084	\\}
4872	5085	, &[_][]const u8{
4873		"tmp.zig:2:6: error: invalid token: 'const'",
	5086	"tmp.zig:2:6: error: expected expression, found 'const'",
4874	5087	});
4875	5088
4876		cases.add("array access of undeclared identifier",
	5089	ctx.objErrStage1("array access of undeclared identifier",
4877	5090	\\export fn f() void {
4878	5091	\\ i[i] = i[i];
4879	5092	\\}
...	...	@@ -4881,7 +5094,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4881	5094	"tmp.zig:2:5: error: use of undeclared identifier 'i'",
4882	5095	});
4883	5096
4884		cases.add("array access of non array",
	5097	ctx.objErrStage1("array access of non array",
4885	5098	\\export fn f() void {
4886	5099	\\ var bad : bool = undefined;
4887	5100	\\ bad[0] = bad[0];
...	...	@@ -4895,7 +5108,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4895	5108	"tmp.zig:7:12: error: array access of non-array type 'bool'",
4896	5109	});
4897	5110
4898		cases.add("array access with non integer index",
	5111	ctx.objErrStage1("array access with non integer index",
4899	5112	\\export fn f() void {
4900	5113	\\ var array = "aoeu";
4901	5114	\\ var bad = false;
...	...	@@ -4911,7 +5124,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4911	5124	"tmp.zig:9:15: error: expected type 'usize', found 'bool'",
4912	5125	});
4913	5126
4914		cases.add("write to const global variable",
	5127	ctx.objErrStage1("write to const global variable",
4915	5128	\\const x : i32 = 99;
4916	5129	\\fn f() void {
4917	5130	\\ x = 1;
...	...	@@ -4921,58 +5134,64 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4921	5134	"tmp.zig:3:9: error: cannot assign to constant",
4922	5135	});
4923	5136
4924		cases.add("missing else clause",
	5137	ctx.objErrStage1("missing else clause",
4925	5138	\\fn f(b: bool) void {
4926	5139	\\ const x : i32 = if (b) h: { break :h 1; };
	5140	\\ _ = x;
4927	5141	\\}
4928	5142	\\fn g(b: bool) void {
4929	5143	\\ const y = if (b) h: { break :h @as(i32, 1); };
	5144	\\ _ = y;
4930	5145	\\}
4931	5146	\\export fn entry() void { f(true); g(true); }
4932	5147	, &[_][]const u8{
4933	5148	"tmp.zig:2:21: error: expected type 'i32', found 'void'",
4934		"tmp.zig:5:15: error: incompatible types: 'i32' and 'void'",
	5149	"tmp.zig:6:15: error: incompatible types: 'i32' and 'void'",
4935	5150	});
4936	5151
4937		cases.add("invalid struct field",
	5152	ctx.objErrStage1("invalid struct field",
4938	5153	\\const A = struct { x : i32, };
4939	5154	\\export fn f() void {
4940	5155	\\ var a : A = undefined;
4941	5156	\\ a.foo = 1;
4942	5157	\\ const y = a.bar;
	5158	\\ _ = y;
4943	5159	\\}
4944	5160	\\export fn g() void {
4945	5161	\\ var a : A = undefined;
4946	5162	\\ const y = a.bar;
	5163	\\ _ = y;
4947	5164	\\}
4948	5165	, &[_][]const u8{
4949	5166	"tmp.zig:4:6: error: no member named 'foo' in struct 'A'",
4950		"tmp.zig:9:16: error: no member named 'bar' in struct 'A'",
	5167	"tmp.zig:10:16: error: no member named 'bar' in struct 'A'",
4951	5168	});
4952	5169
4953		cases.add("redefinition of struct",
	5170	ctx.objErrStage1("redefinition of struct",
4954	5171	\\const A = struct { x : i32, };
4955	5172	\\const A = struct { y : i32, };
4956	5173	, &[_][]const u8{
4957		"tmp.zig:2:1: error: redefinition of 'A'",
	5174	"tmp.zig:2:1: error: redeclaration of 'A'",
	5175	"tmp.zig:1:1: note: other declaration here",
4958	5176	});
4959	5177
4960		cases.add("redefinition of enums",
4961		\\const A = enum {};
4962		\\const A = enum {};
	5178	ctx.objErrStage1("redefinition of enums",
	5179	\\const A = enum {x};
	5180	\\const A = enum {x};
4963	5181	, &[_][]const u8{
4964		"tmp.zig:2:1: error: redefinition of 'A'",
	5182	"tmp.zig:2:1: error: redeclaration of 'A'",
	5183	"tmp.zig:1:1: note: other declaration here",
4965	5184	});
4966	5185
4967		cases.add("redefinition of global variables",
	5186	ctx.objErrStage1("redefinition of global variables",
4968	5187	\\var a : i32 = 1;
4969	5188	\\var a : i32 = 2;
4970	5189	, &[_][]const u8{
4971		"tmp.zig:2:1: error: redefinition of 'a'",
4972		"tmp.zig:1:1: note: previous definition is here",
	5190	"tmp.zig:2:1: error: redeclaration of 'a'",
	5191	"tmp.zig:1:1: note: other declaration here",
4973	5192	});
4974	5193
4975		cases.add("duplicate field in struct value expression",
	5194	ctx.objErrStage1("duplicate field in struct value expression",
4976	5195	\\const A = struct {
4977	5196	\\ x : i32,
4978	5197	\\ y : i32,
...	...	@@ -4985,12 +5204,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4985	5204	\\ .x = 3,
4986	5205	\\ .z = 4,
4987	5206	\\ };
	5207	\\ _ = a;
4988	5208	\\}
4989	5209	, &[_][]const u8{
4990	5210	"tmp.zig:11:9: error: duplicate field",
4991	5211	});
4992	5212
4993		cases.add("missing field in struct value expression",
	5213	ctx.objErrStage1("missing field in struct value expression",
4994	5214	\\const A = struct {
4995	5215	\\ x : i32,
4996	5216	\\ y : i32,
...	...	@@ -5003,12 +5223,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5003	5223	\\ .z = 4,
5004	5224	\\ .y = 2,
5005	5225	\\ };
	5226	\\ _ = a;
5006	5227	\\}
5007	5228	, &[_][]const u8{
5008	5229	"tmp.zig:9:17: error: missing field: 'x'",
5009	5230	});
5010	5231
5011		cases.add("invalid field in struct value expression",
	5232	ctx.objErrStage1("invalid field in struct value expression",
5012	5233	\\const A = struct {
5013	5234	\\ x : i32,
5014	5235	\\ y : i32,
...	...	@@ -5020,12 +5241,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5020	5241	\\ .y = 2,
5021	5242	\\ .foo = 42,
5022	5243	\\ };
	5244	\\ _ = a;
5023	5245	\\}
5024	5246	, &[_][]const u8{
5025	5247	"tmp.zig:10:9: error: no member named 'foo' in struct 'A'",
5026	5248	});
5027	5249
5028		cases.add("invalid break expression",
	5250	ctx.objErrStage1("invalid break expression",
5029	5251	\\export fn f() void {
5030	5252	\\ break;
5031	5253	\\}
...	...	@@ -5033,7 +5255,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5033	5255	"tmp.zig:2:5: error: break expression outside loop",
5034	5256	});
5035	5257
5036		cases.add("invalid continue expression",
	5258	ctx.objErrStage1("invalid continue expression",
5037	5259	\\export fn f() void {
5038	5260	\\ continue;
5039	5261	\\}
...	...	@@ -5041,48 +5263,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5041	5263	"tmp.zig:2:5: error: continue expression outside loop",
5042	5264	});
5043	5265
5044		cases.add("invalid maybe type",
	5266	ctx.objErrStage1("invalid maybe type",
5045	5267	\\export fn f() void {
5046		\\ if (true) \|x\| { }
	5268	\\ if (true) \|x\| { _ = x; }
5047	5269	\\}
5048	5270	, &[_][]const u8{
5049	5271	"tmp.zig:2:9: error: expected optional type, found 'bool'",
5050	5272	});
5051	5273
5052		cases.add("cast unreachable",
	5274	ctx.objErrStage1("cast unreachable",
5053	5275	\\fn f() i32 {
5054	5276	\\ return @as(i32, return 1);
5055	5277	\\}
5056	5278	\\export fn entry() void { _ = f(); }
5057	5279	, &[_][]const u8{
5058	5280	"tmp.zig:2:12: error: unreachable code",
	5281	"tmp.zig:2:21: note: control flow is diverted here",
5059	5282	});
5060	5283
5061		cases.add("invalid builtin fn",
	5284	ctx.objErrStage1("invalid builtin fn",
5062	5285	\\fn f() @bogus(foo) {
5063	5286	\\}
5064	5287	\\export fn entry() void { _ = f(); }
5065	5288	, &[_][]const u8{
5066		"tmp.zig:1:8: error: invalid builtin function: 'bogus'",
	5289	"tmp.zig:1:8: error: invalid builtin function: '@bogus'",
5067	5290	});
5068	5291
5069		cases.add("noalias on non pointer param",
5070		\\fn f(noalias x: i32) void {}
	5292	ctx.objErrStage1("noalias on non pointer param",
	5293	\\fn f(noalias x: i32) void { _ = x; }
5071	5294	\\export fn entry() void { f(1234); }
5072	5295	, &[_][]const u8{
5073	5296	"tmp.zig:1:6: error: noalias on non-pointer parameter",
5074	5297	});
5075	5298
5076		cases.add("struct init syntax for array",
	5299	ctx.objErrStage1("struct init syntax for array",
5077	5300	\\const foo = [3]u16{ .x = 1024 };
5078	5301	\\comptime {
5079	5302	\\ _ = foo;
5080	5303	\\}
5081	5304	, &[_][]const u8{
5082		"tmp.zig:1:21: error: type '[3]u16' does not support struct initialization syntax",
	5305	"tmp.zig:1:13: error: initializing array with struct syntax",
5083	5306	});
5084	5307
5085		cases.add("type variables must be constant",
	5308	ctx.objErrStage1("type variables must be constant",
5086	5309	\\var foo = u8;
5087	5310	\\export fn entry() foo {
5088	5311	\\ return 1;
...	...	@@ -5091,25 +5314,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5091	5314	"tmp.zig:1:1: error: variable of type 'type' must be constant",
5092	5315	});
5093	5316
5094		cases.add("variables shadowing types",
	5317	ctx.objErrStage1("parameter shadowing global",
5095	5318	\\const Foo = struct {};
5096		\\const Bar = struct {};
5097		\\
5098		\\fn f(Foo: i32) void {
5099		\\ var Bar : i32 = undefined;
	5319	\\fn f(Foo: i32) void {}
	5320	\\export fn entry() void {
	5321	\\ f(1234);
5100	5322	\\}
	5323	, &[_][]const u8{
	5324	"tmp.zig:2:6: error: local shadows declaration of 'Foo'",
	5325	"tmp.zig:1:1: note: declared here",
	5326	});
	5327
	5328	ctx.objErrStage1("local variable shadowing global",
	5329	\\const Foo = struct {};
	5330	\\const Bar = struct {};
5101	5331	\\
5102	5332	\\export fn entry() void {
5103		\\ f(1234);
	5333	\\ var Bar : i32 = undefined;
	5334	\\ _ = Bar;
5104	5335	\\}
5105	5336	, &[_][]const u8{
5106		"tmp.zig:4:6: error: redefinition of 'Foo'",
5107		"tmp.zig:1:1: note: previous definition is here",
5108		"tmp.zig:5:5: error: redefinition of 'Bar'",
5109		"tmp.zig:2:1: note: previous definition is here",
	5337	"tmp.zig:5:9: error: local shadows declaration of 'Bar'",
	5338	"tmp.zig:2:1: note: declared here",
5110	5339	});
5111	5340
5112		cases.add("switch expression - missing enumeration prong",
	5341	ctx.objErrStage1("switch expression - missing enumeration prong",
5113	5342	\\const Number = enum {
5114	5343	\\ One,
5115	5344	\\ Two,
...	...	@@ -5129,7 +5358,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5129	5358	"tmp.zig:8:5: error: enumeration value 'Number.Four' not handled in switch",
5130	5359	});
5131	5360
5132		cases.add("switch expression - duplicate enumeration prong",
	5361	ctx.objErrStage1("switch expression - duplicate enumeration prong",
5133	5362	\\const Number = enum {
5134	5363	\\ One,
5135	5364	\\ Two,
...	...	@@ -5149,10 +5378,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5149	5378	\\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
5150	5379	, &[_][]const u8{
5151	5380	"tmp.zig:13:15: error: duplicate switch value",
5152		"tmp.zig:10:15: note: other value is here",
	5381	"tmp.zig:10:15: note: other value here",
5153	5382	});
5154	5383
5155		cases.add("switch expression - duplicate enumeration prong when else present",
	5384	ctx.objErrStage1("switch expression - duplicate enumeration prong when else present",
5156	5385	\\const Number = enum {
5157	5386	\\ One,
5158	5387	\\ Two,
...	...	@@ -5173,10 +5402,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5173	5402	\\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
5174	5403	, &[_][]const u8{
5175	5404	"tmp.zig:13:15: error: duplicate switch value",
5176		"tmp.zig:10:15: note: other value is here",
	5405	"tmp.zig:10:15: note: other value here",
5177	5406	});
5178	5407
5179		cases.add("switch expression - multiple else prongs",
	5408	ctx.objErrStage1("switch expression - multiple else prongs",
5180	5409	\\fn f(x: u32) void {
5181	5410	\\ const value: bool = switch (x) {
5182	5411	\\ 1234 => false,
...	...	@@ -5191,7 +5420,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5191	5420	"tmp.zig:5:9: error: multiple else prongs in switch expression",
5192	5421	});
5193	5422
5194		cases.add("switch expression - non exhaustive integer prongs",
	5423	ctx.objErrStage1("switch expression - non exhaustive integer prongs",
5195	5424	\\fn foo(x: u8) void {
5196	5425	\\ switch (x) {
5197	5426	\\ 0 => {},
...	...	@@ -5202,7 +5431,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5202	5431	"tmp.zig:2:5: error: switch must handle all possibilities",
5203	5432	});
5204	5433
5205		cases.add("switch expression - duplicate or overlapping integer value",
	5434	ctx.objErrStage1("switch expression - duplicate or overlapping integer value",
5206	5435	\\fn foo(x: u8) u8 {
5207	5436	\\ return switch (x) {
5208	5437	\\ 0 ... 100 => @as(u8, 0),
...	...	@@ -5214,11 +5443,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5214	5443	\\export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
5215	5444	, &[_][]const u8{
5216	5445	"tmp.zig:6:9: error: duplicate switch value",
5217		"tmp.zig:5:14: note: previous value is here",
	5446	"tmp.zig:5:14: note: previous value here",
5218	5447	});
5219	5448
5220		cases.add("switch expression - duplicate type",
	5449	ctx.objErrStage1("switch expression - duplicate type",
5221	5450	\\fn foo(comptime T: type, x: T) u8 {
	5451	\\ _ = x;
5222	5452	\\ return switch (T) {
5223	5453	\\ u32 => 0,
5224	5454	\\ u64 => 1,
...	...	@@ -5228,16 +5458,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5228	5458	\\}
5229	5459	\\export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
5230	5460	, &[_][]const u8{
5231		"tmp.zig:5:9: error: duplicate switch value",
5232		"tmp.zig:3:9: note: previous value is here",
	5461	"tmp.zig:6:9: error: duplicate switch value",
	5462	"tmp.zig:4:9: note: previous value here",
5233	5463	});
5234	5464
5235		cases.add("switch expression - duplicate type (struct alias)",
	5465	ctx.objErrStage1("switch expression - duplicate type (struct alias)",
5236	5466	\\const Test = struct {
5237	5467	\\ bar: i32,
5238	5468	\\};
5239	5469	\\const Test2 = Test;
5240	5470	\\fn foo(comptime T: type, x: T) u8 {
	5471	\\ _ = x;
5241	5472	\\ return switch (T) {
5242	5473	\\ Test => 0,
5243	5474	\\ u64 => 1,
...	...	@@ -5247,11 +5478,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5247	5478	\\}
5248	5479	\\export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
5249	5480	, &[_][]const u8{
5250		"tmp.zig:9:9: error: duplicate switch value",
5251		"tmp.zig:7:9: note: previous value is here",
	5481	"tmp.zig:10:9: error: duplicate switch value",
	5482	"tmp.zig:8:9: note: previous value here",
5252	5483	});
5253	5484
5254		cases.add("switch expression - switch on pointer type with no else",
	5485	ctx.objErrStage1("switch expression - switch on pointer type with no else",
5255	5486	\\fn foo(x: *u8) void {
5256	5487	\\ switch (x) {
5257	5488	\\ &y => {},
...	...	@@ -5263,7 +5494,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5263	5494	"tmp.zig:2:5: error: else prong required when switching on type '*u8'",
5264	5495	});
5265	5496
5266		cases.add("global variable initializer must be constant expression",
	5497	ctx.objErrStage1("global variable initializer must be constant expression",
5267	5498	\\extern fn foo() i32;
5268	5499	\\const x = foo();
5269	5500	\\export fn entry() i32 { return x; }
...	...	@@ -5271,7 +5502,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5271	5502	"tmp.zig:2:11: error: unable to evaluate constant expression",
5272	5503	});
5273	5504
5274		cases.add("array concatenation with wrong type",
	5505	ctx.objErrStage1("array concatenation with wrong type",
5275	5506	\\const src = "aoeu";
5276	5507	\\const derp: usize = 1234;
5277	5508	\\const a = derp ++ "foo";
...	...	@@ -5281,7 +5512,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5281	5512	"tmp.zig:3:11: error: expected array, found 'usize'",
5282	5513	});
5283	5514
5284		cases.add("non compile time array concatenation",
	5515	ctx.objErrStage1("non compile time array concatenation",
5285	5516	\\fn f() []u8 {
5286	5517	\\ return s ++ "foo";
5287	5518	\\}
...	...	@@ -5291,7 +5522,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5291	5522	"tmp.zig:2:12: error: unable to evaluate constant expression",
5292	5523	});
5293	5524
5294		cases.add("@cImport with bogus include",
	5525	ctx.objErrStage1("@cImport with bogus include",
5295	5526	\\const c = @cImport(@cInclude("bogus.h"));
5296	5527	\\export fn entry() usize { return @sizeOf(@TypeOf(c.bogo)); }
5297	5528	, &[_][]const u8{
...	...	@@ -5299,7 +5530,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5299	5530	".h:1:10: note: 'bogus.h' file not found",
5300	5531	});
5301	5532
5302		cases.add("address of number literal",
	5533	ctx.objErrStage1("address of number literal",
5303	5534	\\const x = 3;
5304	5535	\\const y = &x;
5305	5536	\\fn foo() *const i32 { return y; }
...	...	@@ -5308,14 +5539,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5308	5539	"tmp.zig:3:30: error: expected type 'const i32', found 'const comptime_int'",
5309	5540	});
5310	5541
5311		cases.add("integer overflow error",
	5542	ctx.objErrStage1("integer overflow error",
5312	5543	\\const x : u8 = 300;
5313	5544	\\export fn entry() usize { return @sizeOf(@TypeOf(x)); }
5314	5545	, &[_][]const u8{
5315	5546	"tmp.zig:1:16: error: integer value 300 cannot be coerced to type 'u8'",
5316	5547	});
5317	5548
5318		cases.add("invalid shift amount error",
	5549	ctx.objErrStage1("invalid shift amount error",
5319	5550	\\const x : u8 = 2;
5320	5551	\\fn f() u16 {
5321	5552	\\ return x << 8;
...	...	@@ -5325,7 +5556,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5325	5556	"tmp.zig:3:17: error: integer value 8 cannot be coerced to type 'u3'",
5326	5557	});
5327	5558
5328		cases.add("missing function call param",
	5559	ctx.objErrStage1("missing function call param",
5329	5560	\\const Foo = struct {
5330	5561	\\ a: i32,
5331	5562	\\ b: i32,
...	...	@@ -5346,6 +5577,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5346	5577	\\
5347	5578	\\fn f(foo: *const Foo, index: usize) void {
5348	5579	\\ const result = members[index]();
	5580	\\ _ = foo;
	5581	\\ _ = result;
5349	5582	\\}
5350	5583	\\
5351	5584	\\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
...	...	@@ -5353,21 +5586,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5353	5586	"tmp.zig:20:34: error: expected 1 argument(s), found 0",
5354	5587	});
5355	5588
5356		cases.add("missing function name",
	5589	ctx.objErrStage1("missing function name",
5357	5590	\\fn () void {}
5358	5591	\\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
5359	5592	, &[_][]const u8{
5360	5593	"tmp.zig:1:1: error: missing function name",
5361	5594	});
5362	5595
5363		cases.add("missing param name",
	5596	ctx.objErrStage1("missing param name",
5364	5597	\\fn f(i32) void {}
5365	5598	\\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
5366	5599	, &[_][]const u8{
5367	5600	"tmp.zig:1:6: error: missing parameter name",
5368	5601	});
5369	5602
5370		cases.add("wrong function type",
	5603	ctx.objErrStage1("wrong function type",
5371	5604	\\const fns = [_]fn() void { a, b, c };
5372	5605	\\fn a() i32 {return 0;}
5373	5606	\\fn b() i32 {return 1;}
...	...	@@ -5377,7 +5610,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5377	5610	"tmp.zig:1:28: error: expected type 'fn() void', found 'fn() i32'",
5378	5611	});
5379	5612
5380		cases.add("extern function pointer mismatch",
	5613	ctx.objErrStage1("extern function pointer mismatch",
5381	5614	\\const fns = [_](fn(i32)i32) { a, b, c };
5382	5615	\\pub fn a(x: i32) i32 {return x + 0;}
5383	5616	\\pub fn b(x: i32) i32 {return x + 1;}
...	...	@@ -5388,15 +5621,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5388	5621	"tmp.zig:1:37: error: expected type 'fn(i32) i32', found 'fn(i32) callconv(.C) i32'",
5389	5622	});
5390	5623
5391		cases.add("colliding invalid top level functions",
	5624	ctx.objErrStage1("colliding invalid top level functions",
5392	5625	\\fn func() bogus {}
5393	5626	\\fn func() bogus {}
5394	5627	\\export fn entry() usize { return @sizeOf(@TypeOf(func)); }
5395	5628	, &[_][]const u8{
5396		"tmp.zig:2:1: error: redefinition of 'func'",
	5629	"tmp.zig:2:1: error: redeclaration of 'func'",
	5630	"tmp.zig:1:1: note: other declaration here",
5397	5631	});
5398	5632
5399		cases.add("non constant expression in array size",
	5633	ctx.objErrStage1("non constant expression in array size",
5400	5634	\\const Foo = struct {
5401	5635	\\ y: [get()]u8,
5402	5636	\\};
...	...	@@ -5409,7 +5643,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5409	5643	"tmp.zig:2:12: note: called from here",
5410	5644	});
5411	5645
5412		cases.add("addition with non numbers",
	5646	ctx.objErrStage1("addition with non numbers",
5413	5647	\\const Foo = struct {
5414	5648	\\ field: i32,
5415	5649	\\};
...	...	@@ -5420,7 +5654,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5420	5654	"tmp.zig:4:28: error: invalid operands to binary expression: 'Foo' and 'Foo'",
5421	5655	});
5422	5656
5423		cases.add("division by zero",
	5657	ctx.objErrStage1("division by zero",
5424	5658	\\const lit_int_x = 1 / 0;
5425	5659	\\const lit_float_x = 1.0 / 0.0;
5426	5660	\\const int_x = @as(u32, 1) / @as(u32, 0);
...	...	@@ -5437,16 +5671,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5437	5671	"tmp.zig:4:31: error: division by zero",
5438	5672	});
5439	5673
5440		cases.add("normal string with newline",
	5674	ctx.objErrStage1("normal string with newline",
5441	5675	\\const foo = "a
5442	5676	\\b";
5443		\\
5444		\\export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
5445	5677	, &[_][]const u8{
5446		"tmp.zig:1:15: error: newline not allowed in string literal",
	5678	"tmp.zig:1:13: error: expected expression, found 'invalid'",
	5679	"tmp.zig:1:15: note: invalid byte: '\\n'",
5447	5680	});
5448	5681
5449		cases.add("invalid comparison for function pointers",
	5682	ctx.objErrStage1("invalid comparison for function pointers",
5450	5683	\\fn foo() void {}
5451	5684	\\const invalid = foo > foo;
5452	5685	\\
...	...	@@ -5455,7 +5688,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5455	5688	"tmp.zig:2:21: error: operator not allowed for type 'fn() void'",
5456	5689	});
5457	5690
5458		cases.add("generic function instance with non-constant expression",
	5691	ctx.objErrStage1("generic function instance with non-constant expression",
5459	5692	\\fn foo(comptime x: i32, y: i32) i32 { return x + y; }
5460	5693	\\fn test1(a: i32, b: i32) i32 {
5461	5694	\\ return foo(a, b);
...	...	@@ -5466,7 +5699,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5466	5699	"tmp.zig:3:16: error: runtime value cannot be passed to comptime arg",
5467	5700	});
5468	5701
5469		cases.add("assign null to non-optional pointer",
	5702	ctx.objErrStage1("assign null to non-optional pointer",
5470	5703	\\const a: *u8 = null;
5471	5704	\\
5472	5705	\\export fn entry() usize { return @sizeOf(@TypeOf(a)); }
...	...	@@ -5474,26 +5707,28 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5474	5707	"tmp.zig:1:16: error: expected type '*u8', found '(null)'",
5475	5708	});
5476	5709
5477		cases.add("indexing an array of size zero",
	5710	ctx.objErrStage1("indexing an array of size zero",
5478	5711	\\const array = [_]u8{};
5479	5712	\\export fn foo() void {
5480	5713	\\ const pointer = &array[0];
	5714	\\ _ = pointer;
5481	5715	\\}
5482	5716	, &[_][]const u8{
5483	5717	"tmp.zig:3:27: error: accessing a zero length array is not allowed",
5484	5718	});
5485	5719
5486		cases.add("indexing an array of size zero with runtime index",
	5720	ctx.objErrStage1("indexing an array of size zero with runtime index",
5487	5721	\\const array = [_]u8{};
5488	5722	\\export fn foo() void {
5489	5723	\\ var index: usize = 0;
5490	5724	\\ const pointer = &array[index];
	5725	\\ _ = pointer;
5491	5726	\\}
5492	5727	, &[_][]const u8{
5493	5728	"tmp.zig:4:27: error: accessing a zero length array is not allowed",
5494	5729	});
5495	5730
5496		cases.add("compile time division by zero",
	5731	ctx.objErrStage1("compile time division by zero",
5497	5732	\\const y = foo(0);
5498	5733	\\fn foo(x: u32) u32 {
5499	5734	\\ return 1 / x;
...	...	@@ -5505,7 +5740,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5505	5740	"tmp.zig:1:14: note: referenced here",
5506	5741	});
5507	5742
5508		cases.add("branch on undefined value",
	5743	ctx.objErrStage1("branch on undefined value",
5509	5744	\\const x = if (undefined) true else false;
5510	5745	\\
5511	5746	\\export fn entry() usize { return @sizeOf(@TypeOf(x)); }
...	...	@@ -5513,7 +5748,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5513	5748	"tmp.zig:1:15: error: use of undefined value here causes undefined behavior",
5514	5749	});
5515	5750
5516		cases.add("div on undefined value",
	5751	ctx.objErrStage1("div on undefined value",
5517	5752	\\comptime {
5518	5753	\\ var a: i64 = undefined;
5519	5754	\\ _ = a / a;
...	...	@@ -5522,7 +5757,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5522	5757	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5523	5758	});
5524	5759
5525		cases.add("div assign on undefined value",
	5760	ctx.objErrStage1("div assign on undefined value",
5526	5761	\\comptime {
5527	5762	\\ var a: i64 = undefined;
5528	5763	\\ a /= a;
...	...	@@ -5531,7 +5766,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5531	5766	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5532	5767	});
5533	5768
5534		cases.add("mod on undefined value",
	5769	ctx.objErrStage1("mod on undefined value",
5535	5770	\\comptime {
5536	5771	\\ var a: i64 = undefined;
5537	5772	\\ _ = a % a;
...	...	@@ -5540,7 +5775,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5540	5775	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5541	5776	});
5542	5777
5543		cases.add("mod assign on undefined value",
	5778	ctx.objErrStage1("mod assign on undefined value",
5544	5779	\\comptime {
5545	5780	\\ var a: i64 = undefined;
5546	5781	\\ a %= a;
...	...	@@ -5549,7 +5784,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5549	5784	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5550	5785	});
5551	5786
5552		cases.add("add on undefined value",
	5787	ctx.objErrStage1("add on undefined value",
5553	5788	\\comptime {
5554	5789	\\ var a: i64 = undefined;
5555	5790	\\ _ = a + a;
...	...	@@ -5558,7 +5793,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5558	5793	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5559	5794	});
5560	5795
5561		cases.add("add assign on undefined value",
	5796	ctx.objErrStage1("add assign on undefined value",
5562	5797	\\comptime {
5563	5798	\\ var a: i64 = undefined;
5564	5799	\\ a += a;
...	...	@@ -5567,7 +5802,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5567	5802	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5568	5803	});
5569	5804
5570		cases.add("add wrap on undefined value",
	5805	ctx.objErrStage1("add wrap on undefined value",
5571	5806	\\comptime {
5572	5807	\\ var a: i64 = undefined;
5573	5808	\\ _ = a +% a;
...	...	@@ -5576,7 +5811,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5576	5811	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5577	5812	});
5578	5813
5579		cases.add("add wrap assign on undefined value",
	5814	ctx.objErrStage1("add wrap assign on undefined value",
5580	5815	\\comptime {
5581	5816	\\ var a: i64 = undefined;
5582	5817	\\ a +%= a;
...	...	@@ -5585,7 +5820,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5585	5820	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5586	5821	});
5587	5822
5588		cases.add("sub on undefined value",
	5823	ctx.objErrStage1("sub on undefined value",
5589	5824	\\comptime {
5590	5825	\\ var a: i64 = undefined;
5591	5826	\\ _ = a - a;
...	...	@@ -5594,7 +5829,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5594	5829	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5595	5830	});
5596	5831
5597		cases.add("sub assign on undefined value",
	5832	ctx.objErrStage1("sub assign on undefined value",
5598	5833	\\comptime {
5599	5834	\\ var a: i64 = undefined;
5600	5835	\\ a -= a;
...	...	@@ -5603,7 +5838,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5603	5838	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5604	5839	});
5605	5840
5606		cases.add("sub wrap on undefined value",
	5841	ctx.objErrStage1("sub wrap on undefined value",
5607	5842	\\comptime {
5608	5843	\\ var a: i64 = undefined;
5609	5844	\\ _ = a -% a;
...	...	@@ -5612,7 +5847,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5612	5847	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5613	5848	});
5614	5849
5615		cases.add("sub wrap assign on undefined value",
	5850	ctx.objErrStage1("sub wrap assign on undefined value",
5616	5851	\\comptime {
5617	5852	\\ var a: i64 = undefined;
5618	5853	\\ a -%= a;
...	...	@@ -5621,7 +5856,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5621	5856	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5622	5857	});
5623	5858
5624		cases.add("mult on undefined value",
	5859	ctx.objErrStage1("mult on undefined value",
5625	5860	\\comptime {
5626	5861	\\ var a: i64 = undefined;
5627	5862	\\ _ = a * a;
...	...	@@ -5630,7 +5865,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5630	5865	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5631	5866	});
5632	5867
5633		cases.add("mult assign on undefined value",
	5868	ctx.objErrStage1("mult assign on undefined value",
5634	5869	\\comptime {
5635	5870	\\ var a: i64 = undefined;
5636	5871	\\ a *= a;
...	...	@@ -5639,7 +5874,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5639	5874	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5640	5875	});
5641	5876
5642		cases.add("mult wrap on undefined value",
	5877	ctx.objErrStage1("mult wrap on undefined value",
5643	5878	\\comptime {
5644	5879	\\ var a: i64 = undefined;
5645	5880	\\ _ = a *% a;
...	...	@@ -5648,7 +5883,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5648	5883	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5649	5884	});
5650	5885
5651		cases.add("mult wrap assign on undefined value",
	5886	ctx.objErrStage1("mult wrap assign on undefined value",
5652	5887	\\comptime {
5653	5888	\\ var a: i64 = undefined;
5654	5889	\\ a *%= a;
...	...	@@ -5657,7 +5892,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5657	5892	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5658	5893	});
5659	5894
5660		cases.add("shift left on undefined value",
	5895	ctx.objErrStage1("shift left on undefined value",
5661	5896	\\comptime {
5662	5897	\\ var a: i64 = undefined;
5663	5898	\\ _ = a << 2;
...	...	@@ -5666,7 +5901,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5666	5901	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5667	5902	});
5668	5903
5669		cases.add("shift left assign on undefined value",
	5904	ctx.objErrStage1("shift left assign on undefined value",
5670	5905	\\comptime {
5671	5906	\\ var a: i64 = undefined;
5672	5907	\\ a <<= 2;
...	...	@@ -5675,7 +5910,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5675	5910	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5676	5911	});
5677	5912
5678		cases.add("shift right on undefined value",
	5913	ctx.objErrStage1("shift right on undefined value",
5679	5914	\\comptime {
5680	5915	\\ var a: i64 = undefined;
5681	5916	\\ _ = a >> 2;
...	...	@@ -5684,7 +5919,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5684	5919	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5685	5920	});
5686	5921
5687		cases.add("shift left assign on undefined value",
	5922	ctx.objErrStage1("shift left assign on undefined value",
5688	5923	\\comptime {
5689	5924	\\ var a: i64 = undefined;
5690	5925	\\ a >>= 2;
...	...	@@ -5693,7 +5928,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5693	5928	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5694	5929	});
5695	5930
5696		cases.add("bin and on undefined value",
	5931	ctx.objErrStage1("bin and on undefined value",
5697	5932	\\comptime {
5698	5933	\\ var a: i64 = undefined;
5699	5934	\\ _ = a & a;
...	...	@@ -5702,7 +5937,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5702	5937	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5703	5938	});
5704	5939
5705		cases.add("bin and assign on undefined value",
	5940	ctx.objErrStage1("bin and assign on undefined value",
5706	5941	\\comptime {
5707	5942	\\ var a: i64 = undefined;
5708	5943	\\ a &= a;
...	...	@@ -5711,7 +5946,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5711	5946	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5712	5947	});
5713	5948
5714		cases.add("bin or on undefined value",
	5949	ctx.objErrStage1("bin or on undefined value",
5715	5950	\\comptime {
5716	5951	\\ var a: i64 = undefined;
5717	5952	\\ _ = a \| a;
...	...	@@ -5720,7 +5955,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5720	5955	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5721	5956	});
5722	5957
5723		cases.add("bin or assign on undefined value",
	5958	ctx.objErrStage1("bin or assign on undefined value",
5724	5959	\\comptime {
5725	5960	\\ var a: i64 = undefined;
5726	5961	\\ a \|= a;
...	...	@@ -5729,7 +5964,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5729	5964	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5730	5965	});
5731	5966
5732		cases.add("bin xor on undefined value",
	5967	ctx.objErrStage1("bin xor on undefined value",
5733	5968	\\comptime {
5734	5969	\\ var a: i64 = undefined;
5735	5970	\\ _ = a ^ a;
...	...	@@ -5738,7 +5973,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5738	5973	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5739	5974	});
5740	5975
5741		cases.add("bin xor assign on undefined value",
	5976	ctx.objErrStage1("bin xor assign on undefined value",
5742	5977	\\comptime {
5743	5978	\\ var a: i64 = undefined;
5744	5979	\\ a ^= a;
...	...	@@ -5747,7 +5982,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5747	5982	"tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
5748	5983	});
5749	5984
5750		cases.add("comparison operators with undefined value",
	5985	ctx.objErrStage1("comparison operators with undefined value",
5751	5986	\\// operator ==
5752	5987	\\comptime {
5753	5988	\\ var a: i64 = undefined;
...	...	@@ -5793,7 +6028,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5793	6028	"tmp.zig:35:11: error: use of undefined value here causes undefined behavior",
5794	6029	});
5795	6030
5796		cases.add("and on undefined value",
	6031	ctx.objErrStage1("and on undefined value",
5797	6032	\\comptime {
5798	6033	\\ var a: bool = undefined;
5799	6034	\\ _ = a and a;
...	...	@@ -5802,7 +6037,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5802	6037	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5803	6038	});
5804	6039
5805		cases.add("or on undefined value",
	6040	ctx.objErrStage1("or on undefined value",
5806	6041	\\comptime {
5807	6042	\\ var a: bool = undefined;
5808	6043	\\ _ = a or a;
...	...	@@ -5811,7 +6046,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5811	6046	"tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
5812	6047	});
5813	6048
5814		cases.add("negate on undefined value",
	6049	ctx.objErrStage1("negate on undefined value",
5815	6050	\\comptime {
5816	6051	\\ var a: i64 = undefined;
5817	6052	\\ _ = -a;
...	...	@@ -5820,7 +6055,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5820	6055	"tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
5821	6056	});
5822	6057
5823		cases.add("negate wrap on undefined value",
	6058	ctx.objErrStage1("negate wrap on undefined value",
5824	6059	\\comptime {
5825	6060	\\ var a: i64 = undefined;
5826	6061	\\ _ = -%a;
...	...	@@ -5829,7 +6064,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5829	6064	"tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
5830	6065	});
5831	6066
5832		cases.add("bin not on undefined value",
	6067	ctx.objErrStage1("bin not on undefined value",
5833	6068	\\comptime {
5834	6069	\\ var a: i64 = undefined;
5835	6070	\\ _ = ~a;
...	...	@@ -5838,7 +6073,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5838	6073	"tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
5839	6074	});
5840	6075
5841		cases.add("bool not on undefined value",
	6076	ctx.objErrStage1("bool not on undefined value",
5842	6077	\\comptime {
5843	6078	\\ var a: bool = undefined;
5844	6079	\\ _ = !a;
...	...	@@ -5847,7 +6082,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5847	6082	"tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
5848	6083	});
5849	6084
5850		cases.add("orelse on undefined value",
	6085	ctx.objErrStage1("orelse on undefined value",
5851	6086	\\comptime {
5852	6087	\\ var a: ?bool = undefined;
5853	6088	\\ _ = a orelse false;
...	...	@@ -5856,16 +6091,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5856	6091	"tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
5857	6092	});
5858	6093
5859		cases.add("catch on undefined value",
	6094	ctx.objErrStage1("catch on undefined value",
5860	6095	\\comptime {
5861	6096	\\ var a: anyerror!bool = undefined;
5862		\\ _ = a catch \|err\| false;
	6097	\\ _ = a catch false;
5863	6098	\\}
5864	6099	, &[_][]const u8{
5865	6100	"tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
5866	6101	});
5867	6102
5868		cases.add("deref on undefined value",
	6103	ctx.objErrStage1("deref on undefined value",
5869	6104	\\comptime {
5870	6105	\\ var a: *u8 = undefined;
5871	6106	\\ _ = a.*;
...	...	@@ -5874,7 +6109,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5874	6109	"tmp.zig:3:9: error: attempt to dereference undefined value",
5875	6110	});
5876	6111
5877		cases.add("endless loop in function evaluation",
	6112	ctx.objErrStage1("endless loop in function evaluation",
5878	6113	\\const seventh_fib_number = fibbonaci(7);
5879	6114	\\fn fibbonaci(x: i32) i32 {
5880	6115	\\ return fibbonaci(x - 1) + fibbonaci(x - 2);
...	...	@@ -5887,16 +6122,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5887	6122	"tmp.zig:6:50: note: referenced here",
5888	6123	});
5889	6124
5890		cases.add("@embedFile with bogus file",
	6125	ctx.objErrStage1("@embedFile with bogus file",
5891	6126	\\const resource = @embedFile("bogus.txt",);
5892	6127	\\
5893	6128	\\export fn entry() usize { return @sizeOf(@TypeOf(resource)); }
5894	6129	, &[_][]const u8{
5895	6130	"tmp.zig:1:29: error: unable to find '",
5896		"bogus.txt'",
5897	6131	});
5898	6132
5899		cases.add("non-const expression in struct literal outside function",
	6133	ctx.objErrStage1("non-const expression in struct literal outside function",
5900	6134	\\const Foo = struct {
5901	6135	\\ x: i32,
5902	6136	\\};
...	...	@@ -5908,7 +6142,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5908	6142	"tmp.zig:4:21: error: unable to evaluate constant expression",
5909	6143	});
5910	6144
5911		cases.add("non-const expression function call with struct return value outside function",
	6145	ctx.objErrStage1("non-const expression function call with struct return value outside function",
5912	6146	\\const Foo = struct {
5913	6147	\\ x: i32,
5914	6148	\\};
...	...	@@ -5925,7 +6159,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5925	6159	"tmp.zig:4:17: note: referenced here",
5926	6160	});
5927	6161
5928		cases.add("undeclared identifier error should mark fn as impure",
	6162	ctx.objErrStage1("undeclared identifier error should mark fn as impure",
5929	6163	\\export fn foo() void {
5930	6164	\\ test_a_thing();
5931	6165	\\}
...	...	@@ -5936,7 +6170,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5936	6170	"tmp.zig:5:5: error: use of undeclared identifier 'bad_fn_call'",
5937	6171	});
5938	6172
5939		cases.add("illegal comparison of types",
	6173	ctx.objErrStage1("illegal comparison of types",
5940	6174	\\fn bad_eql_1(a: []u8, b: []u8) bool {
5941	6175	\\ return a == b;
5942	6176	\\}
...	...	@@ -5955,13 +6189,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5955	6189	"tmp.zig:9:16: error: operator not allowed for type 'EnumWithData'",
5956	6190	});
5957	6191
5958		cases.add("non-const switch number literal",
	6192	ctx.objErrStage1("non-const switch number literal",
5959	6193	\\export fn foo() void {
5960	6194	\\ const x = switch (bar()) {
5961	6195	\\ 1, 2 => 1,
5962	6196	\\ 3, 4 => 2,
5963	6197	\\ else => 3,
5964	6198	\\ };
	6199	\\ _ = x;
5965	6200	\\}
5966	6201	\\fn bar() i32 {
5967	6202	\\ return 2;
...	...	@@ -5970,7 +6205,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5970	6205	"tmp.zig:5:17: error: cannot store runtime value in type 'comptime_int'",
5971	6206	});
5972	6207
5973		cases.add("atomic orderings of cmpxchg - failure stricter than success",
	6208	ctx.objErrStage1("atomic orderings of cmpxchg - failure stricter than success",
5974	6209	\\const AtomicOrder = @import("std").builtin.AtomicOrder;
5975	6210	\\export fn f() void {
5976	6211	\\ var x: i32 = 1234;
...	...	@@ -5980,7 +6215,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5980	6215	"tmp.zig:4:81: error: failure atomic ordering must be no stricter than success",
5981	6216	});
5982	6217
5983		cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",
	6218	ctx.objErrStage1("atomic orderings of cmpxchg - success Monotonic or stricter",
5984	6219	\\const AtomicOrder = @import("std").builtin.AtomicOrder;
5985	6220	\\export fn f() void {
5986	6221	\\ var x: i32 = 1234;
...	...	@@ -5990,7 +6225,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5990	6225	"tmp.zig:4:58: error: success atomic ordering must be Monotonic or stricter",
5991	6226	});
5992	6227
5993		cases.add("negation overflow in function evaluation",
	6228	ctx.objErrStage1("negation overflow in function evaluation",
5994	6229	\\const y = neg(-128);
5995	6230	\\fn neg(x: i8) i8 {
5996	6231	\\ return -x;
...	...	@@ -6002,7 +6237,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6002	6237	"tmp.zig:1:14: note: referenced here",
6003	6238	});
6004	6239
6005		cases.add("add overflow in function evaluation",
	6240	ctx.objErrStage1("add overflow in function evaluation",
6006	6241	\\const y = add(65530, 10);
6007	6242	\\fn add(a: u16, b: u16) u16 {
6008	6243	\\ return a + b;
...	...	@@ -6014,7 +6249,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6014	6249	"tmp.zig:1:14: note: referenced here",
6015	6250	});
6016	6251
6017		cases.add("sub overflow in function evaluation",
	6252	ctx.objErrStage1("sub overflow in function evaluation",
6018	6253	\\const y = sub(10, 20);
6019	6254	\\fn sub(a: u16, b: u16) u16 {
6020	6255	\\ return a - b;
...	...	@@ -6026,7 +6261,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6026	6261	"tmp.zig:1:14: note: referenced here",
6027	6262	});
6028	6263
6029		cases.add("mul overflow in function evaluation",
	6264	ctx.objErrStage1("mul overflow in function evaluation",
6030	6265	\\const y = mul(300, 6000);
6031	6266	\\fn mul(a: u16, b: u16) u16 {
6032	6267	\\ return a * b;
...	...	@@ -6038,7 +6273,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6038	6273	"tmp.zig:1:14: note: referenced here",
6039	6274	});
6040	6275
6041		cases.add("truncate sign mismatch",
	6276	ctx.objErrStage1("truncate sign mismatch",
6042	6277	\\export fn entry1() i8 {
6043	6278	\\ var x: u32 = 10;
6044	6279	\\ return @truncate(i8, x);
...	...	@@ -6062,7 +6297,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6062	6297	"tmp.zig:15:26: error: expected unsigned integer type, found 'i32'",
6063	6298	});
6064	6299
6065		cases.add("try in function with non error return type",
	6300	ctx.objErrStage1("try in function with non error return type",
6066	6301	\\export fn f() void {
6067	6302	\\ try something();
6068	6303	\\}
...	...	@@ -6071,7 +6306,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6071	6306	"tmp.zig:2:5: error: expected type 'void', found 'anyerror'",
6072	6307	});
6073	6308
6074		cases.add("invalid pointer for var type",
	6309	ctx.objErrStage1("invalid pointer for var type",
6075	6310	\\extern fn ext() usize;
6076	6311	\\var bytes: [ext()]u8 = undefined;
6077	6312	\\export fn f() void {
...	...	@@ -6083,7 +6318,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6083	6318	"tmp.zig:2:13: error: unable to evaluate constant expression",
6084	6319	});
6085	6320
6086		cases.add("export function with comptime parameter",
	6321	ctx.objErrStage1("export function with comptime parameter",
6087	6322	\\export fn foo(comptime x: i32, y: i32) i32{
6088	6323	\\ return x + y;
6089	6324	\\}
...	...	@@ -6091,7 +6326,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6091	6326	"tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'",
6092	6327	});
6093	6328
6094		cases.add("extern function with comptime parameter",
	6329	ctx.objErrStage1("extern function with comptime parameter",
6095	6330	\\extern fn foo(comptime x: i32, y: i32) i32;
6096	6331	\\fn f() i32 {
6097	6332	\\ return foo(1, 2);
...	...	@@ -6101,7 +6336,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6101	6336	"tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'",
6102	6337	});
6103	6338
6104		cases.add("non-pure function returns type",
	6339	ctx.objErrStage1("non-pure function returns type",
6105	6340	\\var a: u32 = 0;
6106	6341	\\pub fn List(comptime T: type) type {
6107	6342	\\ a += 1;
...	...	@@ -6125,7 +6360,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6125	6360	"tmp.zig:16:19: note: referenced here",
6126	6361	});
6127	6362
6128		cases.add("bogus method call on slice",
	6363	ctx.objErrStage1("bogus method call on slice",
6129	6364	\\var self = "aoeu";
6130	6365	\\fn f(m: []const u8) void {
6131	6366	\\ m.copy(u8, self[0..], m);
...	...	@@ -6135,9 +6370,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6135	6370	"tmp.zig:3:6: error: no member named 'copy' in '[]const u8'",
6136	6371	});
6137	6372
6138		cases.add("wrong number of arguments for method fn call",
	6373	ctx.objErrStage1("wrong number of arguments for method fn call",
6139	6374	\\const Foo = struct {
6140		\\ fn method(self: *const Foo, a: i32) void {}
	6375	\\ fn method(self: *const Foo, a: i32) void {_ = self; _ = a;}
6141	6376	\\};
6142	6377	\\fn f(foo: *const Foo) void {
6143	6378	\\
...	...	@@ -6148,7 +6383,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6148	6383	"tmp.zig:6:15: error: expected 2 argument(s), found 3",
6149	6384	});
6150	6385
6151		cases.add("assign through constant pointer",
	6386	ctx.objErrStage1("assign through constant pointer",
6152	6387	\\export fn f() void {
6153	6388	\\ var cstr = "Hat";
6154	6389	\\ cstr[0] = 'W';
...	...	@@ -6157,7 +6392,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6157	6392	"tmp.zig:3:13: error: cannot assign to constant",
6158	6393	});
6159	6394
6160		cases.add("assign through constant slice",
	6395	ctx.objErrStage1("assign through constant slice",
6161	6396	\\export fn f() void {
6162	6397	\\ var cstr: []const u8 = "Hat";
6163	6398	\\ cstr[0] = 'W';
...	...	@@ -6166,13 +6401,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6166	6401	"tmp.zig:3:13: error: cannot assign to constant",
6167	6402	});
6168	6403
6169		cases.add("main function with bogus args type",
6170		\\pub fn main(args: [][]bogus) !void {}
	6404	ctx.objErrStage1("main function with bogus args type",
	6405	\\pub fn main(args: [][]bogus) !void {_ = args;}
6171	6406	, &[_][]const u8{
6172	6407	"tmp.zig:1:23: error: use of undeclared identifier 'bogus'",
6173	6408	});
6174	6409
6175		cases.add("misspelled type with pointer only reference",
	6410	ctx.objErrStage1("misspelled type with pointer only reference",
6176	6411	\\const JasonHM = u8;
6177	6412	\\const JasonList = *JsonNode;
6178	6413	\\
...	...	@@ -6200,6 +6435,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6200	6435	\\ var jll: JasonList = undefined;
6201	6436	\\ jll.init(1234);
6202	6437	\\ var jd = JsonNode {.kind = JsonType.JSONArray , .jobject = JsonOA.JSONArray {jll} };
	6438	\\ _ = jd;
6203	6439	\\}
6204	6440	\\
6205	6441	\\export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
...	...	@@ -6207,7 +6443,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6207	6443	"tmp.zig:5:16: error: use of undeclared identifier 'JsonList'",
6208	6444	});
6209	6445
6210		cases.add("method call with first arg type primitive",
	6446	ctx.objErrStage1("method call with first arg type primitive",
6211	6447	\\const Foo = struct {
6212	6448	\\ x: i32,
6213	6449	\\
...	...	@@ -6227,7 +6463,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6227	6463	"tmp.zig:14:5: error: expected type 'i32', found 'Foo'",
6228	6464	});
6229	6465
6230		cases.add("method call with first arg type wrong container",
	6466	ctx.objErrStage1("method call with first arg type wrong container",
6231	6467	\\pub const List = struct {
6232	6468	\\ len: usize,
6233	6469	\\ allocator: *Allocator,
...	...	@@ -6256,7 +6492,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6256	6492	"tmp.zig:23:5: error: expected type 'Allocator', found 'List'",
6257	6493	});
6258	6494
6259		cases.add("binary not on number literal",
	6495	ctx.objErrStage1("binary not on number literal",
6260	6496	\\const TINY_QUANTUM_SHIFT = 4;
6261	6497	\\const TINY_QUANTUM_SIZE = 1 << TINY_QUANTUM_SHIFT;
6262	6498	\\var block_aligned_stuff: usize = (4 + TINY_QUANTUM_SIZE) & ~(TINY_QUANTUM_SIZE - 1);
...	...	@@ -6266,8 +6502,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6266	6502	"tmp.zig:3:60: error: unable to perform binary not operation on type 'comptime_int'",
6267	6503	});
6268	6504
6269		cases.addCase(x: {
6270		const tc = cases.create("multiple files with private function error",
	6505	{
	6506	const case = ctx.obj("multiple files with private function error", .{});
	6507	case.backend = .stage1;
	6508
	6509	case.addSourceFile("foo.zig",
	6510	\\fn privateFunction() void { }
	6511	);
	6512
	6513	case.addError(
6271	6514	\\const foo = @import("foo.zig",);
6272	6515	\\
6273	6516	\\export fn callPrivFunction() void {
...	...	@@ -6277,16 +6520,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6277	6520	"tmp.zig:4:8: error: 'privateFunction' is private",
6278	6521	"foo.zig:1:1: note: declared here",
6279	6522	});
	6523	}
6280	6524
6281		tc.addSourceFile("foo.zig",
6282		\\fn privateFunction() void { }
6283		);
	6525	{
	6526	const case = ctx.obj("multiple files with private member instance function (canonical invocation) error", .{});
	6527	case.backend = .stage1;
6284	6528
6285		break :x tc;
6286		});
	6529	case.addSourceFile("foo.zig",
	6530	\\pub const Foo = struct {
	6531	\\ fn privateFunction(self: *Foo) void { _ = self; }
	6532	\\};
	6533	);
6287	6534
6288		cases.addCase(x: {
6289		const tc = cases.create("multiple files with private member instance function (canonical invocation) error",
	6535	case.addError(
6290	6536	\\const Foo = @import("foo.zig",).Foo;
6291	6537	\\
6292	6538	\\export fn callPrivFunction() void {
...	...	@@ -6297,18 +6543,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6297	6543	"tmp.zig:5:8: error: 'privateFunction' is private",
6298	6544	"foo.zig:2:5: note: declared here",
6299	6545	});
	6546	}
	6547
	6548	{
	6549	const case = ctx.obj("multiple files with private member instance function error", .{});
	6550	case.backend = .stage1;
6300	6551
6301		tc.addSourceFile("foo.zig",
	6552	case.addSourceFile("foo.zig",
6302	6553	\\pub const Foo = struct {
6303		\\ fn privateFunction(self: *Foo) void { }
	6554	\\ fn privateFunction(self: *Foo) void { _ = self; }
6304	6555	\\};
6305	6556	);
6306	6557
6307		break :x tc;
6308		});
6309
6310		cases.addCase(x: {
6311		const tc = cases.create("multiple files with private member instance function error",
	6558	case.addError(
6312	6559	\\const Foo = @import("foo.zig",).Foo;
6313	6560	\\
6314	6561	\\export fn callPrivFunction() void {
...	...	@@ -6319,17 +6566,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6319	6566	"tmp.zig:5:8: error: 'privateFunction' is private",
6320	6567	"foo.zig:2:5: note: declared here",
6321	6568	});
	6569	}
6322	6570
6323		tc.addSourceFile("foo.zig",
6324		\\pub const Foo = struct {
6325		\\ fn privateFunction(self: *Foo) void { }
6326		\\};
6327		);
6328
6329		break :x tc;
6330		});
6331
6332		cases.add("container init with non-type",
	6571	ctx.objErrStage1("container init with non-type",
6333	6572	\\const zero: i32 = 0;
6334	6573	\\const a = zero{1};
6335	6574	\\
...	...	@@ -6338,7 +6577,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6338	6577	"tmp.zig:2:11: error: expected type 'type', found 'i32'",
6339	6578	});
6340	6579
6341		cases.add("assign to constant field",
	6580	ctx.objErrStage1("assign to constant field",
6342	6581	\\const Foo = struct {
6343	6582	\\ field: i32,
6344	6583	\\};
...	...	@@ -6350,7 +6589,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6350	6589	"tmp.zig:6:15: error: cannot assign to constant",
6351	6590	});
6352	6591
6353		cases.add("return from defer expression",
	6592	ctx.objErrStage1("return from defer expression",
6354	6593	\\pub fn testTrickyDefer() !void {
6355	6594	\\ defer canFail() catch {};
6356	6595	\\
...	...	@@ -6367,32 +6606,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6367	6606	\\
6368	6607	\\export fn entry() usize { return @sizeOf(@TypeOf(testTrickyDefer)); }
6369	6608	, &[_][]const u8{
6370		"tmp.zig:4:11: error: cannot return from defer expression",
	6609	"tmp.zig:4:11: error: 'try' not allowed inside defer expression",
6371	6610	});
6372	6611
6373		cases.add("assign too big number to u16",
	6612	ctx.objErrStage1("assign too big number to u16",
6374	6613	\\export fn foo() void {
6375	6614	\\ var vga_mem: u16 = 0xB8000;
	6615	\\ _ = vga_mem;
6376	6616	\\}
6377	6617	, &[_][]const u8{
6378	6618	"tmp.zig:2:24: error: integer value 753664 cannot be coerced to type 'u16'",
6379	6619	});
6380	6620
6381		cases.add("global variable alignment non power of 2",
	6621	ctx.objErrStage1("global variable alignment non power of 2",
6382	6622	\\const some_data: [100]u8 align(3) = undefined;
6383	6623	\\export fn entry() usize { return @sizeOf(@TypeOf(some_data)); }
6384	6624	, &[_][]const u8{
6385	6625	"tmp.zig:1:32: error: alignment value 3 is not a power of 2",
6386	6626	});
6387	6627
6388		cases.add("function alignment non power of 2",
	6628	ctx.objErrStage1("function alignment non power of 2",
6389	6629	\\extern fn foo() align(3) void;
6390	6630	\\export fn entry() void { return foo(); }
6391	6631	, &[_][]const u8{
6392	6632	"tmp.zig:1:23: error: alignment value 3 is not a power of 2",
6393	6633	});
6394	6634
6395		cases.add("compile log",
	6635	ctx.objErrStage1("compile log",
6396	6636	\\export fn foo() void {
6397	6637	\\ comptime bar(12, "hi",);
6398	6638	\\}
...	...	@@ -6407,7 +6647,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6407	6647	"tmp.zig:7:5: error: found compile log statement",
6408	6648	});
6409	6649
6410		cases.add("casting bit offset pointer to regular pointer",
	6650	ctx.objErrStage1("casting bit offset pointer to regular pointer",
6411	6651	\\const BitField = packed struct {
6412	6652	\\ a: u3,
6413	6653	\\ b: u3,
...	...	@@ -6427,7 +6667,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6427	6667	"tmp.zig:8:26: error: expected type 'const u3', found 'align(:3:1) const u3'",
6428	6668	});
6429	6669
6430		cases.add("referring to a struct that is invalid",
	6670	ctx.objErrStage1("referring to a struct that is invalid",
6431	6671	\\const UsbDeviceRequest = struct {
6432	6672	\\ Type: u8,
6433	6673	\\};
...	...	@@ -6444,7 +6684,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6444	6684	"tmp.zig:6:20: note: referenced here",
6445	6685	});
6446	6686
6447		cases.add("control flow uses comptime var at runtime",
	6687	ctx.objErrStage1("control flow uses comptime var at runtime",
6448	6688	\\export fn foo() void {
6449	6689	\\ comptime var i = 0;
6450	6690	\\ while (i < 5) : (i += 1) {
...	...	@@ -6458,7 +6698,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6458	6698	"tmp.zig:3:24: note: compile-time variable assigned here",
6459	6699	});
6460	6700
6461		cases.add("ignored return value",
	6701	ctx.objErrStage1("ignored return value",
6462	6702	\\export fn foo() void {
6463	6703	\\ bar();
6464	6704	\\}
...	...	@@ -6467,7 +6707,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6467	6707	"tmp.zig:2:8: error: expression value is ignored",
6468	6708	});
6469	6709
6470		cases.add("ignored assert-err-ok return value",
	6710	ctx.objErrStage1("ignored assert-err-ok return value",
6471	6711	\\export fn foo() void {
6472	6712	\\ bar() catch unreachable;
6473	6713	\\}
...	...	@@ -6476,7 +6716,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6476	6716	"tmp.zig:2:11: error: expression value is ignored",
6477	6717	});
6478	6718
6479		cases.add("ignored statement value",
	6719	ctx.objErrStage1("ignored statement value",
6480	6720	\\export fn foo() void {
6481	6721	\\ 1;
6482	6722	\\}
...	...	@@ -6484,7 +6724,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6484	6724	"tmp.zig:2:5: error: expression value is ignored",
6485	6725	});
6486	6726
6487		cases.add("ignored comptime statement value",
	6727	ctx.objErrStage1("ignored comptime statement value",
6488	6728	\\export fn foo() void {
6489	6729	\\ comptime {1;}
6490	6730	\\}
...	...	@@ -6492,7 +6732,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6492	6732	"tmp.zig:2:15: error: expression value is ignored",
6493	6733	});
6494	6734
6495		cases.add("ignored comptime value",
	6735	ctx.objErrStage1("ignored comptime value",
6496	6736	\\export fn foo() void {
6497	6737	\\ comptime 1;
6498	6738	\\}
...	...	@@ -6500,7 +6740,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6500	6740	"tmp.zig:2:5: error: expression value is ignored",
6501	6741	});
6502	6742
6503		cases.add("ignored defered statement value",
	6743	ctx.objErrStage1("ignored defered statement value",
6504	6744	\\export fn foo() void {
6505	6745	\\ defer {1;}
6506	6746	\\}
...	...	@@ -6508,7 +6748,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6508	6748	"tmp.zig:2:12: error: expression value is ignored",
6509	6749	});
6510	6750
6511		cases.add("ignored defered function call",
	6751	ctx.objErrStage1("ignored defered function call",
6512	6752	\\export fn foo() void {
6513	6753	\\ defer bar();
6514	6754	\\}
...	...	@@ -6517,7 +6757,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6517	6757	"tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`",
6518	6758	});
6519	6759
6520		cases.add("dereference an array",
	6760	ctx.objErrStage1("dereference an array",
6521	6761	\\var s_buffer: [10]u8 = undefined;
6522	6762	\\pub fn pass(in: []u8) []u8 {
6523	6763	\\ var out = &s_buffer;
...	...	@@ -6530,13 +6770,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6530	6770	"tmp.zig:4:10: error: attempt to dereference non-pointer type '[10]u8'",
6531	6771	});
6532	6772
6533		cases.add("pass const ptr to mutable ptr fn",
	6773	ctx.objErrStage1("pass const ptr to mutable ptr fn",
6534	6774	\\fn foo() bool {
6535	6775	\\ const a = @as([]const u8, "a",);
6536	6776	\\ const b = &a;
6537	6777	\\ return ptrEql(b, b);
6538	6778	\\}
6539	6779	\\fn ptrEql(a: []const u8, b: []const u8) bool {
	6780	\\ _ = a; _ = b;
6540	6781	\\ return true;
6541	6782	\\}
6542	6783	\\
...	...	@@ -6545,8 +6786,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6545	6786	"tmp.zig:4:19: error: expected type '[]const u8', found 'const []const u8'",
6546	6787	});
6547	6788
6548		cases.addCase(x: {
6549		const tc = cases.create("export collision",
	6789	{
	6790	const case = ctx.obj("export collision", .{});
	6791	case.backend = .stage1;
	6792
	6793	case.addSourceFile("foo.zig",
	6794	\\export fn bar() void {}
	6795	\\pub const baz = 1234;
	6796	);
	6797
	6798	case.addError(
6550	6799	\\const foo = @import("foo.zig",);
6551	6800	\\
6552	6801	\\export fn bar() usize {
...	...	@@ -6556,18 +6805,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6556	6805	"foo.zig:1:1: error: exported symbol collision: 'bar'",
6557	6806	"tmp.zig:3:1: note: other symbol here",
6558	6807	});
	6808	}
6559	6809
6560		tc.addSourceFile("foo.zig",
6561		\\export fn bar() void {}
6562		\\pub const baz = 1234;
6563		);
6564
6565		break :x tc;
6566		});
6567
6568		cases.add("implicit cast from array to mutable slice",
	6810	ctx.objErrStage1("implicit cast from array to mutable slice",
6569	6811	\\var global_array: [10]i32 = undefined;
6570		\\fn foo(param: []i32) void {}
	6812	\\fn foo(param: []i32) void {_ = param;}
6571	6813	\\export fn entry() void {
6572	6814	\\ foo(global_array);
6573	6815	\\}
...	...	@@ -6575,7 +6817,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6575	6817	"tmp.zig:4:9: error: expected type '[]i32', found '[10]i32'",
6576	6818	});
6577	6819
6578		cases.add("ptrcast to non-pointer",
	6820	ctx.objErrStage1("ptrcast to non-pointer",
6579	6821	\\export fn entry(a: *i32) usize {
6580	6822	\\ return @ptrCast(usize, a);
6581	6823	\\}
...	...	@@ -6583,7 +6825,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6583	6825	"tmp.zig:2:21: error: expected pointer, found 'usize'",
6584	6826	});
6585	6827
6586		cases.add("asm at compile time",
	6828	ctx.objErrStage1("asm at compile time",
6587	6829	\\comptime {
6588	6830	\\ doSomeAsm();
6589	6831	\\}
...	...	@@ -6599,25 +6841,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6599	6841	"tmp.zig:6:5: error: unable to evaluate constant expression",
6600	6842	});
6601	6843
6602		cases.add("invalid member of builtin enum",
	6844	ctx.objErrStage1("invalid member of builtin enum",
6603	6845	\\const builtin = @import("std").builtin;
6604	6846	\\export fn entry() void {
6605	6847	\\ const foo = builtin.Mode.x86;
	6848	\\ _ = foo;
6606	6849	\\}
6607	6850	, &[_][]const u8{
6608	6851	"tmp.zig:3:29: error: container 'std.builtin.Mode' has no member called 'x86'",
6609	6852	});
6610	6853
6611		cases.add("int to ptr of 0 bits",
	6854	ctx.objErrStage1("int to ptr of 0 bits",
6612	6855	\\export fn foo() void {
6613	6856	\\ var x: usize = 0x1000;
6614	6857	\\ var y: void = @intToPtr(void, x);
	6858	\\ _ = y;
6615	6859	\\}
6616	6860	, &[_][]const u8{
6617	6861	"tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information",
6618	6862	});
6619	6863
6620		cases.add("@fieldParentPtr - non struct",
	6864	ctx.objErrStage1("@fieldParentPtr - non struct",
6621	6865	\\const Foo = i32;
6622	6866	\\export fn foo(a: i32) Foo {
6623	6867	\\ return @fieldParentPtr(Foo, "a", a);
...	...	@@ -6626,7 +6870,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6626	6870	"tmp.zig:3:28: error: expected struct type, found 'i32'",
6627	6871	});
6628	6872
6629		cases.add("@fieldParentPtr - bad field name",
	6873	ctx.objErrStage1("@fieldParentPtr - bad field name",
6630	6874	\\const Foo = extern struct {
6631	6875	\\ derp: i32,
6632	6876	\\};
...	...	@@ -6637,7 +6881,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6637	6881	"tmp.zig:5:33: error: struct 'Foo' has no field 'a'",
6638	6882	});
6639	6883
6640		cases.add("@fieldParentPtr - field pointer is not pointer",
	6884	ctx.objErrStage1("@fieldParentPtr - field pointer is not pointer",
6641	6885	\\const Foo = extern struct {
6642	6886	\\ a: i32,
6643	6887	\\};
...	...	@@ -6648,7 +6892,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6648	6892	"tmp.zig:5:38: error: expected pointer, found 'i32'",
6649	6893	});
6650	6894
6651		cases.add("@fieldParentPtr - comptime field ptr not based on struct",
	6895	ctx.objErrStage1("@fieldParentPtr - comptime field ptr not based on struct",
6652	6896	\\const Foo = struct {
6653	6897	\\ a: i32,
6654	6898	\\ b: i32,
...	...	@@ -6658,12 +6902,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6658	6902	\\comptime {
6659	6903	\\ const field_ptr = @intToPtr(*i32, 0x1234);
6660	6904	\\ const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr);
	6905	\\ _ = another_foo_ptr;
6661	6906	\\}
6662	6907	, &[_][]const u8{
6663	6908	"tmp.zig:9:55: error: pointer value not based on parent struct",
6664	6909	});
6665	6910
6666		cases.add("@fieldParentPtr - comptime wrong field index",
	6911	ctx.objErrStage1("@fieldParentPtr - comptime wrong field index",
6667	6912	\\const Foo = struct {
6668	6913	\\ a: i32,
6669	6914	\\ b: i32,
...	...	@@ -6672,12 +6917,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6672	6917	\\
6673	6918	\\comptime {
6674	6919	\\ const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a);
	6920	\\ _ = another_foo_ptr;
6675	6921	\\}
6676	6922	, &[_][]const u8{
6677	6923	"tmp.zig:8:29: error: field 'b' has index 1 but pointer value is index 0 of struct 'Foo'",
6678	6924	});
6679	6925
6680		cases.add("@offsetOf - non struct",
	6926	ctx.objErrStage1("@offsetOf - non struct",
6681	6927	\\const Foo = i32;
6682	6928	\\export fn foo() usize {
6683	6929	\\ return @offsetOf(Foo, "a",);
...	...	@@ -6686,7 +6932,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6686	6932	"tmp.zig:3:22: error: expected struct type, found 'i32'",
6687	6933	});
6688	6934
6689		cases.add("@offsetOf - bad field name",
	6935	ctx.objErrStage1("@offsetOf - bad field name",
6690	6936	\\const Foo = struct {
6691	6937	\\ derp: i32,
6692	6938	\\};
...	...	@@ -6697,20 +6943,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6697	6943	"tmp.zig:5:27: error: struct 'Foo' has no field 'a'",
6698	6944	});
6699	6945
6700		cases.addExe("missing main fn in executable",
	6946	ctx.exeErrStage1("missing main fn in executable",
6701	6947	\\
6702	6948	, &[_][]const u8{
6703	6949	"error: root source file has no member called 'main'",
6704	6950	});
6705	6951
6706		cases.addExe("private main fn",
	6952	ctx.exeErrStage1("private main fn",
6707	6953	\\fn main() void {}
6708	6954	, &[_][]const u8{
6709	6955	"error: 'main' is private",
6710	6956	"tmp.zig:1:1: note: declared here",
6711	6957	});
6712	6958
6713		cases.add("setting a section on a local variable",
	6959	ctx.objErrStage1("setting a section on a local variable",
6714	6960	\\export fn entry() i32 {
6715	6961	\\ var foo: i32 linksection(".text2") = 1234;
6716	6962	\\ return foo;
...	...	@@ -6719,7 +6965,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6719	6965	"tmp.zig:2:30: error: cannot set section of local variable 'foo'",
6720	6966	});
6721	6967
6722		cases.add("inner struct member shadowing outer struct member",
	6968	ctx.objErrStage1("inner struct member shadowing outer struct member",
6723	6969	\\fn A() type {
6724	6970	\\ return struct {
6725	6971	\\ b: B(),
...	...	@@ -6741,10 +6987,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6741	6987	\\}
6742	6988	, &[_][]const u8{
6743	6989	"tmp.zig:9:17: error: redefinition of 'Self'",
6744		"tmp.zig:5:9: note: previous definition is here",
	6990	"tmp.zig:5:9: note: previous definition here",
6745	6991	});
6746	6992
6747		cases.add("while expected bool, got optional",
	6993	ctx.objErrStage1("while expected bool, got optional",
6748	6994	\\export fn foo() void {
6749	6995	\\ while (bar()) {}
6750	6996	\\}
...	...	@@ -6753,7 +6999,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6753	6999	"tmp.zig:2:15: error: expected type 'bool', found '?i32'",
6754	7000	});
6755	7001
6756		cases.add("while expected bool, got error union",
	7002	ctx.objErrStage1("while expected bool, got error union",
6757	7003	\\export fn foo() void {
6758	7004	\\ while (bar()) {}
6759	7005	\\}
...	...	@@ -6762,36 +7008,36 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6762	7008	"tmp.zig:2:15: error: expected type 'bool', found 'anyerror!i32'",
6763	7009	});
6764	7010
6765		cases.add("while expected optional, got bool",
	7011	ctx.objErrStage1("while expected optional, got bool",
6766	7012	\\export fn foo() void {
6767		\\ while (bar()) \|x\| {}
	7013	\\ while (bar()) \|x\| {_ = x;}
6768	7014	\\}
6769	7015	\\fn bar() bool { return true; }
6770	7016	, &[_][]const u8{
6771	7017	"tmp.zig:2:15: error: expected optional type, found 'bool'",
6772	7018	});
6773	7019
6774		cases.add("while expected optional, got error union",
	7020	ctx.objErrStage1("while expected optional, got error union",
6775	7021	\\export fn foo() void {
6776		\\ while (bar()) \|x\| {}
	7022	\\ while (bar()) \|x\| {_ = x;}
6777	7023	\\}
6778	7024	\\fn bar() anyerror!i32 { return 1; }
6779	7025	, &[_][]const u8{
6780	7026	"tmp.zig:2:15: error: expected optional type, found 'anyerror!i32'",
6781	7027	});
6782	7028
6783		cases.add("while expected error union, got bool",
	7029	ctx.objErrStage1("while expected error union, got bool",
6784	7030	\\export fn foo() void {
6785		\\ while (bar()) \|x\| {} else \|err\| {}
	7031	\\ while (bar()) \|x\| {_ = x;} else \|err\| {_ = err;}
6786	7032	\\}
6787	7033	\\fn bar() bool { return true; }
6788	7034	, &[_][]const u8{
6789	7035	"tmp.zig:2:15: error: expected error union type, found 'bool'",
6790	7036	});
6791	7037
6792		cases.add("while expected error union, got optional",
	7038	ctx.objErrStage1("while expected error union, got optional",
6793	7039	\\export fn foo() void {
6794		\\ while (bar()) \|x\| {} else \|err\| {}
	7040	\\ while (bar()) \|x\| {_ = x;} else \|err\| {_ = err;}
6795	7041	\\}
6796	7042	\\fn bar() ?i32 { return 1; }
6797	7043	, &[_][]const u8{
...	...	@@ -6799,7 +7045,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6799	7045	});
6800	7046
6801	7047	// TODO test this in stage2, but we won't even try in stage1
6802		//cases.add("inline fn calls itself indirectly",
	7048	//ctx.objErrStage1("inline fn calls itself indirectly",
6803	7049	// \\export fn foo() void {
6804	7050	// \\ bar();
6805	7051	// \\}
...	...	@@ -6816,7 +7062,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6816	7062	// "tmp.zig:4:1: error: unable to inline function",
6817	7063	//});
6818	7064
6819		//cases.add("save reference to inline function",
	7065	//ctx.objErrStage1("save reference to inline function",
6820	7066	// \\export fn foo() void {
6821	7067	// \\ quux(@ptrToInt(bar));
6822	7068	// \\}
...	...	@@ -6826,7 +7072,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6826	7072	// "tmp.zig:4:1: error: unable to inline function",
6827	7073	//});
6828	7074
6829		cases.add("signed integer division",
	7075	ctx.objErrStage1("signed integer division",
6830	7076	\\export fn foo(a: i32, b: i32) i32 {
6831	7077	\\ return a / b;
6832	7078	\\}
...	...	@@ -6834,7 +7080,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6834	7080	"tmp.zig:2:14: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact",
6835	7081	});
6836	7082
6837		cases.add("signed integer remainder division",
	7083	ctx.objErrStage1("signed integer remainder division",
6838	7084	\\export fn foo(a: i32, b: i32) i32 {
6839	7085	\\ return a % b;
6840	7086	\\}
...	...	@@ -6842,27 +7088,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6842	7088	"tmp.zig:2:14: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod",
6843	7089	});
6844	7090
6845		cases.add("compile-time division by zero",
	7091	ctx.objErrStage1("compile-time division by zero",
6846	7092	\\comptime {
6847	7093	\\ const a: i32 = 1;
6848	7094	\\ const b: i32 = 0;
6849	7095	\\ const c = a / b;
	7096	\\ _ = c;
6850	7097	\\}
6851	7098	, &[_][]const u8{
6852	7099	"tmp.zig:4:17: error: division by zero",
6853	7100	});
6854	7101
6855		cases.add("compile-time remainder division by zero",
	7102	ctx.objErrStage1("compile-time remainder division by zero",
6856	7103	\\comptime {
6857	7104	\\ const a: i32 = 1;
6858	7105	\\ const b: i32 = 0;
6859	7106	\\ const c = a % b;
	7107	\\ _ = c;
6860	7108	\\}
6861	7109	, &[_][]const u8{
6862	7110	"tmp.zig:4:17: error: division by zero",
6863	7111	});
6864	7112
6865		cases.add("@setRuntimeSafety twice for same scope",
	7113	ctx.objErrStage1("@setRuntimeSafety twice for same scope",
6866	7114	\\export fn foo() void {
6867	7115	\\ @setRuntimeSafety(false);
6868	7116	\\ @setRuntimeSafety(false);
...	...	@@ -6872,7 +7120,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6872	7120	"tmp.zig:2:5: note: first set here",
6873	7121	});
6874	7122
6875		cases.add("@setFloatMode twice for same scope",
	7123	ctx.objErrStage1("@setFloatMode twice for same scope",
6876	7124	\\export fn foo() void {
6877	7125	\\ @setFloatMode(@import("std").builtin.FloatMode.Optimized);
6878	7126	\\ @setFloatMode(@import("std").builtin.FloatMode.Optimized);
...	...	@@ -6882,15 +7130,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6882	7130	"tmp.zig:2:5: note: first set here",
6883	7131	});
6884	7132
6885		cases.add("array access of type",
	7133	ctx.objErrStage1("array access of type",
6886	7134	\\export fn foo() void {
6887	7135	\\ var b: u8[40] = undefined;
	7136	\\ _ = b;
6888	7137	\\}
6889	7138	, &[_][]const u8{
6890	7139	"tmp.zig:2:14: error: array access of non-array type 'type'",
6891	7140	});
6892	7141
6893		cases.add("cannot break out of defer expression",
	7142	ctx.objErrStage1("cannot break out of defer expression",
6894	7143	\\export fn foo() void {
6895	7144	\\ while (true) {
6896	7145	\\ defer {
...	...	@@ -6902,7 +7151,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6902	7151	"tmp.zig:4:13: error: cannot break out of defer expression",
6903	7152	});
6904	7153
6905		cases.add("cannot continue out of defer expression",
	7154	ctx.objErrStage1("cannot continue out of defer expression",
6906	7155	\\export fn foo() void {
6907	7156	\\ while (true) {
6908	7157	\\ defer {
...	...	@@ -6914,11 +7163,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6914	7163	"tmp.zig:4:13: error: cannot continue out of defer expression",
6915	7164	});
6916	7165
6917		cases.add("calling a generic function only known at runtime",
	7166	ctx.objErrStage1("calling a generic function only known at runtime",
6918	7167	\\var foos = [_]fn(anytype) void { foo1, foo2 };
6919	7168	\\
6920		\\fn foo1(arg: anytype) void {}
6921		\\fn foo2(arg: anytype) void {}
	7169	\\fn foo1(arg: anytype) void {_ = arg;}
	7170	\\fn foo2(arg: anytype) void {_ = arg;}
6922	7171	\\
6923	7172	\\pub fn main() !void {
6924	7173	\\ foos[0](true);
...	...	@@ -6927,7 +7176,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6927	7176	"tmp.zig:7:9: error: calling a generic function requires compile-time known function value",
6928	7177	});
6929	7178
6930		cases.add("@compileError shows traceback of references that caused it",
	7179	ctx.objErrStage1("@compileError shows traceback of references that caused it",
6931	7180	\\const foo = @compileError("aoeu",);
6932	7181	\\
6933	7182	\\const bar = baz + foo;
...	...	@@ -6942,23 +7191,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6942	7191	"tmp.zig:7:12: note: referenced here",
6943	7192	});
6944	7193
6945		cases.add("float literal too large error",
	7194	ctx.objErrStage1("float literal too large error",
6946	7195	\\comptime {
6947	7196	\\ const a = 0x1.0p18495;
	7197	\\ _ = a;
6948	7198	\\}
6949	7199	, &[_][]const u8{
6950	7200	"tmp.zig:2:15: error: float literal out of range of any type",
6951	7201	});
6952	7202
6953		cases.add("float literal too small error (denormal)",
	7203	ctx.objErrStage1("float literal too small error (denormal)",
6954	7204	\\comptime {
6955	7205	\\ const a = 0x1.0p-19000;
	7206	\\ _ = a;
6956	7207	\\}
6957	7208	, &[_][]const u8{
6958	7209	"tmp.zig:2:15: error: float literal out of range of any type",
6959	7210	});
6960	7211
6961		cases.add("explicit cast float literal to integer when there is a fraction component",
	7212	ctx.objErrStage1("explicit cast float literal to integer when there is a fraction component",
6962	7213	\\export fn entry() i32 {
6963	7214	\\ return @as(i32, 12.34);
6964	7215	\\}
...	...	@@ -6966,7 +7217,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6966	7217	"tmp.zig:2:21: error: fractional component prevents float value 12.340000 from being casted to type 'i32'",
6967	7218	});
6968	7219
6969		cases.add("non pointer given to @ptrToInt",
	7220	ctx.objErrStage1("non pointer given to @ptrToInt",
6970	7221	\\export fn entry(x: i32) usize {
6971	7222	\\ return @ptrToInt(x);
6972	7223	\\}
...	...	@@ -6974,23 +7225,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6974	7225	"tmp.zig:2:22: error: expected pointer, found 'i32'",
6975	7226	});
6976	7227
6977		cases.add("@shlExact shifts out 1 bits",
	7228	ctx.objErrStage1("@shlExact shifts out 1 bits",
6978	7229	\\comptime {
6979	7230	\\ const x = @shlExact(@as(u8, 0b01010101), 2);
	7231	\\ _ = x;
6980	7232	\\}
6981	7233	, &[_][]const u8{
6982	7234	"tmp.zig:2:15: error: operation caused overflow",
6983	7235	});
6984	7236
6985		cases.add("@shrExact shifts out 1 bits",
	7237	ctx.objErrStage1("@shrExact shifts out 1 bits",
6986	7238	\\comptime {
6987	7239	\\ const x = @shrExact(@as(u8, 0b10101010), 2);
	7240	\\ _ = x;
6988	7241	\\}
6989	7242	, &[_][]const u8{
6990	7243	"tmp.zig:2:15: error: exact shift shifted out 1 bits",
6991	7244	});
6992	7245
6993		cases.add("shifting without int type or comptime known",
	7246	ctx.objErrStage1("shifting without int type or comptime known",
6994	7247	\\export fn entry(x: u8) u8 {
6995	7248	\\ return 0x11 << x;
6996	7249	\\}
...	...	@@ -6998,7 +7251,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6998	7251	"tmp.zig:2:17: error: LHS of shift must be a fixed-width integer type, or RHS must be compile-time known",
6999	7252	});
7000	7253
7001		cases.add("shifting RHS is log2 of LHS int bit width",
	7254	ctx.objErrStage1("shifting RHS is log2 of LHS int bit width",
7002	7255	\\export fn entry(x: u8, y: u8) u8 {
7003	7256	\\ return x << y;
7004	7257	\\}
...	...	@@ -7006,16 +7259,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7006	7259	"tmp.zig:2:17: error: expected type 'u3', found 'u8'",
7007	7260	});
7008	7261
7009		cases.add("globally shadowing a primitive type",
	7262	ctx.objErrStage1("globally shadowing a primitive type",
7010	7263	\\const u16 = u8;
7011	7264	\\export fn entry() void {
7012	7265	\\ const a: u16 = 300;
	7266	\\ _ = a;
7013	7267	\\}
7014	7268	, &[_][]const u8{
7015	7269	"tmp.zig:1:1: error: declaration shadows primitive type 'u16'",
7016	7270	});
7017	7271
7018		cases.add("implicitly increasing pointer alignment",
	7272	ctx.objErrStage1("implicitly increasing pointer alignment",
7019	7273	\\const Foo = packed struct {
7020	7274	\\ a: u8,
7021	7275	\\ b: u32,
...	...	@@ -7033,7 +7287,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7033	7287	"tmp.zig:8:13: error: expected type 'u32', found 'align(1) u32'",
7034	7288	});
7035	7289
7036		cases.add("implicitly increasing slice alignment",
	7290	ctx.objErrStage1("implicitly increasing slice alignment",
7037	7291	\\const Foo = packed struct {
7038	7292	\\ a: u8,
7039	7293	\\ b: u32,
...	...	@@ -7054,7 +7308,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7054	7308	"tmp.zig:9:26: note: '*[1]u32' has alignment 4",
7055	7309	});
7056	7310
7057		cases.add("increase pointer alignment in @ptrCast",
	7311	ctx.objErrStage1("increase pointer alignment in @ptrCast",
7058	7312	\\export fn entry() u32 {
7059	7313	\\ var bytes: [4]u8 = [_]u8{0x01, 0x02, 0x03, 0x04};
7060	7314	\\ const ptr = @ptrCast(*u32, &bytes[0]);
...	...	@@ -7066,7 +7320,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7066	7320	"tmp.zig:3:26: note: '*u32' has alignment 4",
7067	7321	});
7068	7322
7069		cases.add("@alignCast expects pointer or slice",
	7323	ctx.objErrStage1("@alignCast expects pointer or slice",
7070	7324	\\export fn entry() void {
7071	7325	\\ @alignCast(4, @as(u32, 3));
7072	7326	\\}
...	...	@@ -7074,7 +7328,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7074	7328	"tmp.zig:2:19: error: expected pointer or slice, found 'u32'",
7075	7329	});
7076	7330
7077		cases.add("passing an under-aligned function pointer",
	7331	ctx.objErrStage1("passing an under-aligned function pointer",
7078	7332	\\export fn entry() void {
7079	7333	\\ testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
7080	7334	\\}
...	...	@@ -7086,7 +7340,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7086	7340	"tmp.zig:2:35: error: expected type 'fn() align(8) i32', found 'fn() align(4) i32'",
7087	7341	});
7088	7342
7089		cases.add("passing a not-aligned-enough pointer to cmpxchg",
	7343	ctx.objErrStage1("passing a not-aligned-enough pointer to cmpxchg",
7090	7344	\\const AtomicOrder = @import("std").builtin.AtomicOrder;
7091	7345	\\export fn entry() bool {
7092	7346	\\ var x: i32 align(1) = 1234;
...	...	@@ -7097,15 +7351,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7097	7351	"tmp.zig:4:32: error: expected type 'i32', found 'align(1) i32'",
7098	7352	});
7099	7353
7100		cases.add("wrong size to an array literal",
	7354	ctx.objErrStage1("wrong size to an array literal",
7101	7355	\\comptime {
7102	7356	\\ const array = [2]u8{1, 2, 3};
	7357	\\ _ = array;
7103	7358	\\}
7104	7359	, &[_][]const u8{
7105	7360	"tmp.zig:2:31: error: index 2 outside array of size 2",
7106	7361	});
7107	7362
7108		cases.add("wrong pointer coerced to pointer to opaque {}",
	7363	ctx.objErrStage1("wrong pointer coerced to pointer to opaque {}",
7109	7364	\\const Derp = opaque {};
7110	7365	\\extern fn bar(d: *Derp) void;
7111	7366	\\export fn foo() void {
...	...	@@ -7116,53 +7371,66 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7116	7371	"tmp.zig:5:9: error: expected type 'Derp', found 'c_void'",
7117	7372	});
7118	7373
7119		cases.add("non-const variables of things that require const variables",
	7374	ctx.objErrStage1("non-const variables of things that require const variables",
7120	7375	\\export fn entry1() void {
7121	7376	\\ var m2 = &2;
	7377	\\ _ = m2;
7122	7378	\\}
7123	7379	\\export fn entry2() void {
7124	7380	\\ var a = undefined;
	7381	\\ _ = a;
7125	7382	\\}
7126	7383	\\export fn entry3() void {
7127	7384	\\ var b = 1;
	7385	\\ _ = b;
7128	7386	\\}
7129	7387	\\export fn entry4() void {
7130	7388	\\ var c = 1.0;
	7389	\\ _ = c;
7131	7390	\\}
7132	7391	\\export fn entry5() void {
7133	7392	\\ var d = null;
	7393	\\ _ = d;
7134	7394	\\}
7135	7395	\\export fn entry6(opaque_: *Opaque) void {
7136	7396	\\ var e = opaque_.*;
	7397	\\ _ = e;
7137	7398	\\}
7138	7399	\\export fn entry7() void {
7139	7400	\\ var f = i32;
	7401	\\ _ = f;
7140	7402	\\}
7141	7403	\\export fn entry8() void {
7142	7404	\\ var h = (Foo {}).bar;
7143		\\}
7144		\\export fn entry9() void {
7145		\\ var z: noreturn = return;
	7405	\\ _ = h;
7146	7406	\\}
7147	7407	\\const Opaque = opaque {};
7148	7408	\\const Foo = struct {
7149		\\ fn bar(self: *const Foo) void {}
	7409	\\ fn bar(self: *const Foo) void {_ = self;}
7150	7410	\\};
7151	7411	, &[_][]const u8{
7152	7412	"tmp.zig:2:4: error: variable of type '*const comptime_int' must be const or comptime",
7153		"tmp.zig:5:4: error: variable of type '(undefined)' must be const or comptime",
7154		"tmp.zig:8:4: error: variable of type 'comptime_int' must be const or comptime",
7155		"tmp.zig:8:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
7156		"tmp.zig:11:4: error: variable of type 'comptime_float' must be const or comptime",
7157		"tmp.zig:11:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
7158		"tmp.zig:14:4: error: variable of type '(null)' must be const or comptime",
7159		"tmp.zig:17:4: error: variable of type 'Opaque' not allowed",
7160		"tmp.zig:20:4: error: variable of type 'type' must be const or comptime",
7161		"tmp.zig:23:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime",
7162		"tmp.zig:26:22: error: unreachable code",
	7413	"tmp.zig:6:4: error: variable of type '(undefined)' must be const or comptime",
	7414	"tmp.zig:10:4: error: variable of type 'comptime_int' must be const or comptime",
	7415	"tmp.zig:10:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
	7416	"tmp.zig:14:4: error: variable of type 'comptime_float' must be const or comptime",
	7417	"tmp.zig:14:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
	7418	"tmp.zig:18:4: error: variable of type '(null)' must be const or comptime",
	7419	"tmp.zig:22:4: error: variable of type 'Opaque' not allowed",
	7420	"tmp.zig:26:4: error: variable of type 'type' must be const or comptime",
	7421	"tmp.zig:30:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime",
	7422	});
	7423
	7424	ctx.objErrStage1("variable with type 'noreturn'",
	7425	\\export fn entry9() void {
	7426	\\ var z: noreturn = return;
	7427	\\}
	7428	, &[_][]const u8{
	7429	"tmp.zig:2:5: error: unreachable code",
	7430	"tmp.zig:2:23: note: control flow is diverted here",
7163	7431	});
7164	7432
7165		cases.add("wrong types given to atomic order args in cmpxchg",
	7433	ctx.objErrStage1("wrong types given to atomic order args in cmpxchg",
7166	7434	\\export fn entry() void {
7167	7435	\\ var x: i32 = 1234;
7168	7436	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, @as(u32, 1234), @as(u32, 1234))) {}
...	...	@@ -7171,7 +7439,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7171	7439	"tmp.zig:3:47: error: expected type 'std.builtin.AtomicOrder', found 'u32'",
7172	7440	});
7173	7441
7174		cases.add("wrong types given to @export",
	7442	ctx.objErrStage1("wrong types given to @export",
7175	7443	\\fn entry() callconv(.C) void { }
7176	7444	\\comptime {
7177	7445	\\ @export(entry, .{.name = "entry", .linkage = @as(u32, 1234) });
...	...	@@ -7180,7 +7448,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7180	7448	"tmp.zig:3:59: error: expected type 'std.builtin.GlobalLinkage', found 'comptime_int'",
7181	7449	});
7182	7450
7183		cases.add("struct with invalid field",
	7451	ctx.objErrStage1("struct with invalid field",
7184	7452	\\const std = @import("std",);
7185	7453	\\const Allocator = std.mem.Allocator;
7186	7454	\\const ArrayList = std.ArrayList;
...	...	@@ -7203,12 +7471,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7203	7471	\\ .text = MdText.init(&std.testing.allocator),
7204	7472	\\ .weight = HeaderWeight.H1,
7205	7473	\\ };
	7474	\\ _ = a;
7206	7475	\\}
7207	7476	, &[_][]const u8{
7208	7477	"tmp.zig:14:17: error: use of undeclared identifier 'HeaderValue'",
7209	7478	});
7210	7479
7211		cases.add("@setAlignStack outside function",
	7480	ctx.objErrStage1("@setAlignStack outside function",
7212	7481	\\comptime {
7213	7482	\\ @setAlignStack(16);
7214	7483	\\}
...	...	@@ -7216,7 +7485,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7216	7485	"tmp.zig:2:5: error: @setAlignStack outside function",
7217	7486	});
7218	7487
7219		cases.add("@setAlignStack in naked function",
	7488	ctx.objErrStage1("@setAlignStack in naked function",
7220	7489	\\export fn entry() callconv(.Naked) void {
7221	7490	\\ @setAlignStack(16);
7222	7491	\\}
...	...	@@ -7224,7 +7493,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7224	7493	"tmp.zig:2:5: error: @setAlignStack in naked function",
7225	7494	});
7226	7495
7227		cases.add("@setAlignStack in inline function",
	7496	ctx.objErrStage1("@setAlignStack in inline function",
7228	7497	\\export fn entry() void {
7229	7498	\\ foo();
7230	7499	\\}
...	...	@@ -7235,7 +7504,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7235	7504	"tmp.zig:5:5: error: @setAlignStack in inline function",
7236	7505	});
7237	7506
7238		cases.add("@setAlignStack set twice",
	7507	ctx.objErrStage1("@setAlignStack set twice",
7239	7508	\\export fn entry() void {
7240	7509	\\ @setAlignStack(16);
7241	7510	\\ @setAlignStack(16);
...	...	@@ -7245,7 +7514,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7245	7514	"tmp.zig:2:5: note: first set here",
7246	7515	});
7247	7516
7248		cases.add("@setAlignStack too big",
	7517	ctx.objErrStage1("@setAlignStack too big",
7249	7518	\\export fn entry() void {
7250	7519	\\ @setAlignStack(511 + 1);
7251	7520	\\}
...	...	@@ -7253,7 +7522,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7253	7522	"tmp.zig:2:5: error: attempt to @setAlignStack(512); maximum is 256",
7254	7523	});
7255	7524
7256		cases.add("storing runtime value in compile time variable then using it",
	7525	ctx.objErrStage1("storing runtime value in compile time variable then using it",
7257	7526	\\const Mode = @import("std").builtin.Mode;
7258	7527	\\
7259	7528	\\fn Free(comptime filename: []const u8) TestCase {
...	...	@@ -7290,24 +7559,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7290	7559	\\ };
7291	7560	\\
7292	7561	\\ for ([_]Mode { Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast }) \|mode\| {
	7562	\\ _ = mode;
7293	7563	\\ inline for (tests) \|test_case\| {
7294	7564	\\ const foo = test_case.filename ++ ".zig";
	7565	\\ _ = foo;
7295	7566	\\ }
7296	7567	\\ }
7297	7568	\\}
7298	7569	, &[_][]const u8{
7299		"tmp.zig:37:29: error: cannot store runtime value in compile time variable",
	7570	"tmp.zig:38:29: error: cannot store runtime value in compile time variable",
7300	7571	});
7301	7572
7302		cases.add("invalid legacy unicode escape",
	7573	ctx.objErrStage1("invalid legacy unicode escape",
7303	7574	\\export fn entry() void {
7304	7575	\\ const a = '\U1234';
7305	7576	\\}
7306	7577	, &[_][]const u8{
7307		"tmp.zig:2:17: error: invalid character: 'U'",
	7578	"tmp.zig:2:15: error: expected expression, found 'invalid'",
	7579	"tmp.zig:2:18: note: invalid byte: '1'",
7308	7580	});
7309	7581
7310		cases.add("invalid empty unicode escape",
	7582	ctx.objErrStage1("invalid empty unicode escape",
7311	7583	\\export fn entry() void {
7312	7584	\\ const a = '\u{}';
7313	7585	\\}
...	...	@@ -7315,21 +7587,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7315	7587	"tmp.zig:2:19: error: empty unicode escape sequence",
7316	7588	});
7317	7589
7318		cases.add("non-printable invalid character", "\xff\xfe" ++
7319		\\fn test() bool {\r
7320		\\ true\r
7321		\\}
7322		, &[_][]const u8{
7323		"tmp.zig:1:1: error: invalid character: '\\xff'",
	7590	ctx.objErrStage1("non-printable invalid character", "\xff\xfe" ++
	7591	"fn foo() bool {\r\n" ++
	7592	" return true;\r\n" ++
	7593	"}\r\n", &[_][]const u8{
	7594	"tmp.zig:1:1: error: expected test, comptime, var decl, or container field, found 'invalid'",
	7595	"tmp.zig:1:1: note: invalid byte: '\\xff'",
7324	7596	});
7325	7597
7326		cases.add("non-printable invalid character with escape alternative", "fn test() bool {\n" ++
7327		"\ttrue\n" ++
	7598	ctx.objErrStage1("non-printable invalid character with escape alternative", "fn foo() bool {\n" ++
	7599	"\treturn true;\n" ++
7328	7600	"}\n", &[_][]const u8{
7329	7601	"tmp.zig:2:1: error: invalid character: '\\t'",
7330	7602	});
7331	7603
7332		cases.add("calling var args extern function, passing array instead of pointer",
	7604	ctx.objErrStage1("calling var args extern function, passing array instead of pointer",
7333	7605	\\export fn entry() void {
7334	7606	\\ foo("hello".*,);
7335	7607	\\}
...	...	@@ -7338,7 +7610,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7338	7610	"tmp.zig:2:16: error: expected type '*const u8', found '[5:0]u8'",
7339	7611	});
7340	7612
7341		cases.add("constant inside comptime function has compile error",
	7613	ctx.objErrStage1("constant inside comptime function has compile error",
7342	7614	\\const ContextAllocator = MemoryPool(usize);
7343	7615	\\
7344	7616	\\pub fn MemoryPool(comptime T: type) type {
...	...	@@ -7353,12 +7625,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7353	7625	\\ var allocator: ContextAllocator = undefined;
7354	7626	\\}
7355	7627	, &[_][]const u8{
7356		"tmp.zig:4:25: error: aoeu",
7357		"tmp.zig:1:36: note: referenced here",
7358		"tmp.zig:12:20: note: referenced here",
	7628	"tmp.zig:4:5: error: unreachable code",
	7629	"tmp.zig:4:25: note: control flow is diverted here",
	7630	"tmp.zig:12:9: error: unused local variable",
7359	7631	});
7360	7632
7361		cases.add("specify enum tag type that is too small",
	7633	ctx.objErrStage1("specify enum tag type that is too small",
7362	7634	\\const Small = enum (u2) {
7363	7635	\\ One,
7364	7636	\\ Two,
...	...	@@ -7369,12 +7641,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7369	7641	\\
7370	7642	\\export fn entry() void {
7371	7643	\\ var x = Small.One;
	7644	\\ _ = x;
7372	7645	\\}
7373	7646	, &[_][]const u8{
7374	7647	"tmp.zig:6:5: error: enumeration value 4 too large for type 'u2'",
7375	7648	});
7376	7649
7377		cases.add("specify non-integer enum tag type",
	7650	ctx.objErrStage1("specify non-integer enum tag type",
7378	7651	\\const Small = enum (f32) {
7379	7652	\\ One,
7380	7653	\\ Two,
...	...	@@ -7383,12 +7656,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7383	7656	\\
7384	7657	\\export fn entry() void {
7385	7658	\\ var x = Small.One;
	7659	\\ _ = x;
7386	7660	\\}
7387	7661	, &[_][]const u8{
7388	7662	"tmp.zig:1:21: error: expected integer, found 'f32'",
7389	7663	});
7390	7664
7391		cases.add("implicitly casting enum to tag type",
	7665	ctx.objErrStage1("implicitly casting enum to tag type",
7392	7666	\\const Small = enum(u2) {
7393	7667	\\ One,
7394	7668	\\ Two,
...	...	@@ -7398,12 +7672,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7398	7672	\\
7399	7673	\\export fn entry() void {
7400	7674	\\ var x: u2 = Small.Two;
	7675	\\ _ = x;
7401	7676	\\}
7402	7677	, &[_][]const u8{
7403	7678	"tmp.zig:9:22: error: expected type 'u2', found 'Small'",
7404	7679	});
7405	7680
7406		cases.add("explicitly casting non tag type to enum",
	7681	ctx.objErrStage1("explicitly casting non tag type to enum",
7407	7682	\\const Small = enum(u2) {
7408	7683	\\ One,
7409	7684	\\ Two,
...	...	@@ -7414,42 +7689,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7414	7689	\\export fn entry() void {
7415	7690	\\ var y = @as(u3, 3);
7416	7691	\\ var x = @intToEnum(Small, y);
	7692	\\ _ = x;
7417	7693	\\}
7418	7694	, &[_][]const u8{
7419	7695	"tmp.zig:10:31: error: expected type 'u2', found 'u3'",
7420	7696	});
7421	7697
7422		cases.add("union fields with value assignments",
	7698	ctx.objErrStage1("union fields with value assignments",
7423	7699	\\const MultipleChoice = union {
7424	7700	\\ A: i32 = 20,
7425	7701	\\};
7426	7702	\\export fn entry() void {
7427	7703	\\ var x: MultipleChoice = undefined;
	7704	\\ _ = x;
7428	7705	\\}
7429	7706	, &[_][]const u8{
7430		"tmp.zig:2:14: error: untagged union field assignment",
7431		"tmp.zig:1:24: note: consider 'union(enum)' here",
	7707	"tmp.zig:1:24: error: explicitly valued tagged union missing integer tag type",
	7708	"tmp.zig:2:14: note: tag value specified here",
7432	7709	});
7433	7710
7434		cases.add("enum with 0 fields",
	7711	ctx.objErrStage1("enum with 0 fields",
7435	7712	\\const Foo = enum {};
7436		\\export fn entry() usize {
7437		\\ return @sizeOf(Foo);
7438		\\}
7439	7713	, &[_][]const u8{
7440		"tmp.zig:1:13: error: enums must have 1 or more fields",
	7714	"tmp.zig:1:13: error: enum declarations must have at least one tag",
7441	7715	});
7442	7716
7443		cases.add("union with 0 fields",
	7717	ctx.objErrStage1("union with 0 fields",
7444	7718	\\const Foo = union {};
7445		\\export fn entry() usize {
7446		\\ return @sizeOf(Foo);
7447		\\}
7448	7719	, &[_][]const u8{
7449		"tmp.zig:1:13: error: unions must have 1 or more fields",
	7720	"tmp.zig:1:13: error: union declarations must have at least one tag",
7450	7721	});
7451	7722
7452		cases.add("enum value already taken",
	7723	ctx.objErrStage1("enum value already taken",
7453	7724	\\const MultipleChoice = enum(u32) {
7454	7725	\\ A = 20,
7455	7726	\\ B = 40,
...	...	@@ -7459,13 +7730,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7459	7730	\\};
7460	7731	\\export fn entry() void {
7461	7732	\\ var x = MultipleChoice.C;
	7733	\\ _ = x;
7462	7734	\\}
7463	7735	, &[_][]const u8{
7464	7736	"tmp.zig:6:5: error: enum tag value 60 already taken",
7465	7737	"tmp.zig:4:5: note: other occurrence here",
7466	7738	});
7467	7739
7468		cases.add("union with specified enum omits field",
	7740	ctx.objErrStage1("union with specified enum omits field",
7469	7741	\\const Letter = enum {
7470	7742	\\ A,
7471	7743	\\ B,
...	...	@@ -7483,29 +7755,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7483	7755	"tmp.zig:4:5: note: declared here",
7484	7756	});
7485	7757
7486		cases.add("non-integer tag type to automatic union enum",
	7758	ctx.objErrStage1("non-integer tag type to automatic union enum",
7487	7759	\\const Foo = union(enum(f32)) {
7488	7760	\\ A: i32,
7489	7761	\\};
7490	7762	\\export fn entry() void {
7491	7763	\\ const x = @typeInfo(Foo).Union.tag_type.?;
	7764	\\ _ = x;
7492	7765	\\}
7493	7766	, &[_][]const u8{
7494	7767	"tmp.zig:1:24: error: expected integer tag type, found 'f32'",
7495	7768	});
7496	7769
7497		cases.add("non-enum tag type passed to union",
	7770	ctx.objErrStage1("non-enum tag type passed to union",
7498	7771	\\const Foo = union(u32) {
7499	7772	\\ A: i32,
7500	7773	\\};
7501	7774	\\export fn entry() void {
7502	7775	\\ const x = @typeInfo(Foo).Union.tag_type.?;
	7776	\\ _ = x;
7503	7777	\\}
7504	7778	, &[_][]const u8{
7505	7779	"tmp.zig:1:19: error: expected enum tag type, found 'u32'",
7506	7780	});
7507	7781
7508		cases.add("union auto-enum value already taken",
	7782	ctx.objErrStage1("union auto-enum value already taken",
7509	7783	\\const MultipleChoice = union(enum(u32)) {
7510	7784	\\ A = 20,
7511	7785	\\ B = 40,
...	...	@@ -7515,13 +7789,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7515	7789	\\};
7516	7790	\\export fn entry() void {
7517	7791	\\ var x = MultipleChoice { .C = {} };
	7792	\\ _ = x;
7518	7793	\\}
7519	7794	, &[_][]const u8{
7520	7795	"tmp.zig:6:9: error: enum tag value 60 already taken",
7521	7796	"tmp.zig:4:9: note: other occurrence here",
7522	7797	});
7523	7798
7524		cases.add("union enum field does not match enum",
	7799	ctx.objErrStage1("union enum field does not match enum",
7525	7800	\\const Letter = enum {
7526	7801	\\ A,
7527	7802	\\ B,
...	...	@@ -7535,49 +7810,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7535	7810	\\};
7536	7811	\\export fn entry() void {
7537	7812	\\ var a = Payload {.A = 1234};
	7813	\\ _ = a;
7538	7814	\\}
7539	7815	, &[_][]const u8{
7540	7816	"tmp.zig:10:5: error: enum field not found: 'D'",
7541	7817	"tmp.zig:1:16: note: enum declared here",
7542	7818	});
7543	7819
7544		cases.add("field type supplied in an enum",
	7820	ctx.objErrStage1("field type supplied in an enum",
7545	7821	\\const Letter = enum {
7546	7822	\\ A: void,
7547	7823	\\ B,
7548	7824	\\ C,
7549	7825	\\};
7550		\\export fn entry() void {
7551		\\ var b = Letter.B;
7552		\\}
7553	7826	, &[_][]const u8{
7554		"tmp.zig:2:8: error: structs and unions, not enums, support field types",
7555		"tmp.zig:1:16: note: consider 'union(enum)' here",
	7827	"tmp.zig:2:8: error: enum fields do not have types",
	7828	"tmp.zig:1:16: note: consider 'union(enum)' here to make it a tagged union",
7556	7829	});
7557	7830
7558		cases.add("struct field missing type",
	7831	ctx.objErrStage1("struct field missing type",
7559	7832	\\const Letter = struct {
7560	7833	\\ A,
7561	7834	\\};
7562	7835	\\export fn entry() void {
7563	7836	\\ var a = Letter { .A = {} };
	7837	\\ _ = a;
7564	7838	\\}
7565	7839	, &[_][]const u8{
7566	7840	"tmp.zig:2:5: error: struct field missing type",
7567	7841	});
7568	7842
7569		cases.add("extern union field missing type",
	7843	ctx.objErrStage1("extern union field missing type",
7570	7844	\\const Letter = extern union {
7571	7845	\\ A,
7572	7846	\\};
7573	7847	\\export fn entry() void {
7574	7848	\\ var a = Letter { .A = {} };
	7849	\\ _ = a;
7575	7850	\\}
7576	7851	, &[_][]const u8{
7577	7852	"tmp.zig:2:5: error: union field missing type",
7578	7853	});
7579	7854
7580		cases.add("extern union given enum tag type",
	7855	ctx.objErrStage1("extern union given enum tag type",
7581	7856	\\const Letter = enum {
7582	7857	\\ A,
7583	7858	\\ B,
...	...	@@ -7590,12 +7865,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7590	7865	\\};
7591	7866	\\export fn entry() void {
7592	7867	\\ var a = Payload { .A = 1234 };
	7868	\\ _ = a;
7593	7869	\\}
7594	7870	, &[_][]const u8{
7595	7871	"tmp.zig:6:30: error: extern union does not support enum tag type",
7596	7872	});
7597	7873
7598		cases.add("packed union given enum tag type",
	7874	ctx.objErrStage1("packed union given enum tag type",
7599	7875	\\const Letter = enum {
7600	7876	\\ A,
7601	7877	\\ B,
...	...	@@ -7608,12 +7884,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7608	7884	\\};
7609	7885	\\export fn entry() void {
7610	7886	\\ var a = Payload { .A = 1234 };
	7887	\\ _ = a;
7611	7888	\\}
7612	7889	, &[_][]const u8{
7613	7890	"tmp.zig:6:30: error: packed union does not support enum tag type",
7614	7891	});
7615	7892
7616		cases.add("packed union with automatic layout field",
	7893	ctx.objErrStage1("packed union with automatic layout field",
7617	7894	\\const Foo = struct {
7618	7895	\\ a: u32,
7619	7896	\\ b: f32,
...	...	@@ -7624,12 +7901,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7624	7901	\\};
7625	7902	\\export fn entry() void {
7626	7903	\\ var a = Payload { .B = true };
	7904	\\ _ = a;
7627	7905	\\}
7628	7906	, &[_][]const u8{
7629	7907	"tmp.zig:6:5: error: non-packed, non-extern struct 'Foo' not allowed in packed union; no guaranteed in-memory representation",
7630	7908	});
7631	7909
7632		cases.add("switch on union with no attached enum",
	7910	ctx.objErrStage1("switch on union with no attached enum",
7633	7911	\\const Payload = union {
7634	7912	\\ A: i32,
7635	7913	\\ B: f64,
...	...	@@ -7650,20 +7928,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7650	7928	"tmp.zig:1:17: note: consider 'union(enum)' here",
7651	7929	});
7652	7930
7653		cases.add("enum in field count range but not matching tag",
	7931	ctx.objErrStage1("enum in field count range but not matching tag",
7654	7932	\\const Foo = enum(u32) {
7655	7933	\\ A = 10,
7656	7934	\\ B = 11,
7657	7935	\\};
7658	7936	\\export fn entry() void {
7659	7937	\\ var x = @intToEnum(Foo, 0);
	7938	\\ _ = x;
7660	7939	\\}
7661	7940	, &[_][]const u8{
7662	7941	"tmp.zig:6:13: error: enum 'Foo' has no tag matching integer value 0",
7663	7942	"tmp.zig:1:13: note: 'Foo' declared here",
7664	7943	});
7665	7944
7666		cases.add("comptime cast enum to union but field has payload",
	7945	ctx.objErrStage1("comptime cast enum to union but field has payload",
7667	7946	\\const Letter = enum { A, B, C };
7668	7947	\\const Value = union(Letter) {
7669	7948	\\ A: i32,
...	...	@@ -7672,13 +7951,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7672	7951	\\};
7673	7952	\\export fn entry() void {
7674	7953	\\ var x: Value = Letter.A;
	7954	\\ _ = x;
7675	7955	\\}
7676	7956	, &[_][]const u8{
7677	7957	"tmp.zig:8:26: error: cast to union 'Value' must initialize 'i32' field 'A'",
7678	7958	"tmp.zig:3:5: note: field 'A' declared here",
7679	7959	});
7680	7960
7681		cases.add("runtime cast to union which has non-void fields",
	7961	ctx.objErrStage1("runtime cast to union which has non-void fields",
7682	7962	\\const Letter = enum { A, B, C };
7683	7963	\\const Value = union(Letter) {
7684	7964	\\ A: i32,
...	...	@@ -7690,35 +7970,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7690	7970	\\}
7691	7971	\\fn foo(l: Letter) void {
7692	7972	\\ var x: Value = l;
	7973	\\ _ = x;
7693	7974	\\}
7694	7975	, &[_][]const u8{
7695	7976	"tmp.zig:11:20: error: runtime cast to union 'Value' which has non-void fields",
7696	7977	"tmp.zig:3:5: note: field 'A' has type 'i32'",
7697	7978	});
7698	7979
7699		cases.add("taking byte offset of void field in struct",
	7980	ctx.objErrStage1("taking byte offset of void field in struct",
7700	7981	\\const Empty = struct {
7701	7982	\\ val: void,
7702	7983	\\};
7703	7984	\\export fn foo() void {
7704	7985	\\ const fieldOffset = @offsetOf(Empty, "val",);
	7986	\\ _ = fieldOffset;
7705	7987	\\}
7706	7988	, &[_][]const u8{
7707	7989	"tmp.zig:5:42: error: zero-bit field 'val' in struct 'Empty' has no offset",
7708	7990	});
7709	7991
7710		cases.add("taking bit offset of void field in struct",
	7992	ctx.objErrStage1("taking bit offset of void field in struct",
7711	7993	\\const Empty = struct {
7712	7994	\\ val: void,
7713	7995	\\};
7714	7996	\\export fn foo() void {
7715	7997	\\ const fieldOffset = @bitOffsetOf(Empty, "val",);
	7998	\\ _ = fieldOffset;
7716	7999	\\}
7717	8000	, &[_][]const u8{
7718	8001	"tmp.zig:5:45: error: zero-bit field 'val' in struct 'Empty' has no offset",
7719	8002	});
7720	8003
7721		cases.add("invalid union field access in comptime",
	8004	ctx.objErrStage1("invalid union field access in comptime",
7722	8005	\\const Foo = union {
7723	8006	\\ Bar: u8,
7724	8007	\\ Baz: void,
...	...	@@ -7726,12 +8009,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7726	8009	\\comptime {
7727	8010	\\ var foo = Foo {.Baz = {}};
7728	8011	\\ const bar_val = foo.Bar;
	8012	\\ _ = bar_val;
7729	8013	\\}
7730	8014	, &[_][]const u8{
7731	8015	"tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set",
7732	8016	});
7733	8017
7734		cases.add("unsupported modifier at start of asm output constraint",
	8018	ctx.objErrStage1("unsupported modifier at start of asm output constraint",
7735	8019	\\export fn foo() void {
7736	8020	\\ var bar: u32 = 3;
7737	8021	\\ asm volatile ("" : [baz]"+r"(bar) : : "");
...	...	@@ -7740,7 +8024,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7740	8024	"tmp.zig:3:5: error: invalid modifier starting output constraint for 'baz': '+', only '=' is supported. Compiler TODO: see https://github.com/ziglang/zig/issues/215",
7741	8025	});
7742	8026
7743		cases.add("comptime_int in asm input",
	8027	ctx.objErrStage1("comptime_int in asm input",
7744	8028	\\export fn foo() void {
7745	8029	\\ asm volatile ("" : : [bar]"r"(3) : "");
7746	8030	\\}
...	...	@@ -7748,7 +8032,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7748	8032	"tmp.zig:2:35: error: expected sized integer or sized float, found comptime_int",
7749	8033	});
7750	8034
7751		cases.add("comptime_float in asm input",
	8035	ctx.objErrStage1("comptime_float in asm input",
7752	8036	\\export fn foo() void {
7753	8037	\\ asm volatile ("" : : [bar]"r"(3.17) : "");
7754	8038	\\}
...	...	@@ -7756,7 +8040,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7756	8040	"tmp.zig:2:35: error: expected sized integer or sized float, found comptime_float",
7757	8041	});
7758	8042
7759		cases.add("runtime assignment to comptime struct type",
	8043	ctx.objErrStage1("runtime assignment to comptime struct type",
7760	8044	\\const Foo = struct {
7761	8045	\\ Bar: u8,
7762	8046	\\ Baz: type,
...	...	@@ -7764,12 +8048,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7764	8048	\\export fn f() void {
7765	8049	\\ var x: u8 = 0;
7766	8050	\\ const foo = Foo { .Bar = x, .Baz = u8 };
	8051	\\ _ = foo;
7767	8052	\\}
7768	8053	, &[_][]const u8{
7769	8054	"tmp.zig:7:23: error: unable to evaluate constant expression",
7770	8055	});
7771	8056
7772		cases.add("runtime assignment to comptime union type",
	8057	ctx.objErrStage1("runtime assignment to comptime union type",
7773	8058	\\const Foo = union {
7774	8059	\\ Bar: u8,
7775	8060	\\ Baz: type,
...	...	@@ -7777,16 +8062,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7777	8062	\\export fn f() void {
7778	8063	\\ var x: u8 = 0;
7779	8064	\\ const foo = Foo { .Bar = x };
	8065	\\ _ = foo;
7780	8066	\\}
7781	8067	, &[_][]const u8{
7782	8068	"tmp.zig:7:23: error: unable to evaluate constant expression",
7783	8069	});
7784	8070
7785		cases.addTest("@shuffle with selected index past first vector length",
	8071	ctx.testErrStage1("@shuffle with selected index past first vector length",
7786	8072	\\export fn entry() void {
7787	8073	\\ const v: @import("std").meta.Vector(4, u32) = [4]u32{ 10, 11, 12, 13 };
7788	8074	\\ const x: @import("std").meta.Vector(4, u32) = [4]u32{ 14, 15, 16, 17 };
7789	8075	\\ var z = @shuffle(u32, v, x, [8]i32{ 0, 1, 2, 3, 7, 6, 5, 4 });
	8076	\\ _ = z;
7790	8077	\\}
7791	8078	, &[_][]const u8{
7792	8079	"tmp.zig:4:39: error: mask index '4' has out-of-bounds selection",
...	...	@@ -7794,27 +8081,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7794	8081	"tmp.zig:4:30: note: selections from the second vector are specified with negative numbers",
7795	8082	});
7796	8083
7797		cases.addTest("nested vectors",
	8084	ctx.testErrStage1("nested vectors",
7798	8085	\\export fn entry() void {
7799	8086	\\ const V1 = @import("std").meta.Vector(4, u8);
7800	8087	\\ const V2 = @Type(@import("std").builtin.TypeInfo{ .Vector = .{ .len = 4, .child = V1 } });
7801	8088	\\ var v: V2 = undefined;
	8089	\\ _ = v;
7802	8090	\\}
7803	8091	, &[_][]const u8{
7804	8092	"tmp.zig:3:53: error: vector element type must be integer, float, bool, or pointer; '@Vector(4, u8)' is invalid",
7805	8093	"tmp.zig:3:16: note: referenced here",
7806	8094	});
7807	8095
7808		cases.addTest("bad @splat type",
	8096	ctx.testErrStage1("bad @splat type",
7809	8097	\\export fn entry() void {
7810	8098	\\ const c = 4;
7811	8099	\\ var v = @splat(4, c);
	8100	\\ _ = v;
7812	8101	\\}
7813	8102	, &[_][]const u8{
7814	8103	"tmp.zig:3:23: error: vector element type must be integer, float, bool, or pointer; 'comptime_int' is invalid",
7815	8104	});
7816	8105
7817		cases.add("compileLog of tagged enum doesn't crash the compiler",
	8106	ctx.objErrStage1("compileLog of tagged enum doesn't crash the compiler",
7818	8107	\\const Bar = union(enum(u32)) {
7819	8108	\\ X: i32 = 1
7820	8109	\\};
...	...	@@ -7830,28 +8119,30 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7830	8119	"tmp.zig:6:5: error: found compile log statement",
7831	8120	});
7832	8121
7833		cases.add("attempted implicit cast from const T to [1]T",
	8122	ctx.objErrStage1("attempted implicit cast from const T to [1]T",
7834	8123	\\export fn entry(byte: u8) void {
7835	8124	\\ const w: i32 = 1234;
7836	8125	\\ var x: *const i32 = &w;
7837	8126	\\ var y: *[1]i32 = x;
7838	8127	\\ y[0] += 1;
	8128	\\ _ = byte;
7839	8129	\\}
7840	8130	, &[_][]const u8{
7841	8131	"tmp.zig:4:22: error: expected type '[1]i32', found 'const i32'",
7842	8132	"tmp.zig:4:22: note: cast discards const qualifier",
7843	8133	});
7844	8134
7845		cases.add("attempted implicit cast from *const T to []T",
	8135	ctx.objErrStage1("attempted implicit cast from *const T to []T",
7846	8136	\\export fn entry() void {
7847	8137	\\ const u: u32 = 42;
7848	8138	\\ const x: []u32 = &u;
	8139	\\ _ = x;
7849	8140	\\}
7850	8141	, &[_][]const u8{
7851	8142	"tmp.zig:3:23: error: expected type '[]u32', found '*const u32'",
7852	8143	});
7853	8144
7854		cases.add("for loop body expression ignored",
	8145	ctx.objErrStage1("for loop body expression ignored",
7855	8146	\\fn returns() usize {
7856	8147	\\ return 2;
7857	8148	\\}
...	...	@@ -7861,21 +8152,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7861	8152	\\export fn f2() void {
7862	8153	\\ var x: anyerror!i32 = error.Bad;
7863	8154	\\ for ("hello") \|_\| returns() else unreachable;
	8155	\\ _ = x;
7864	8156	\\}
7865	8157	, &[_][]const u8{
7866	8158	"tmp.zig:5:30: error: expression value is ignored",
7867	8159	"tmp.zig:9:30: error: expression value is ignored",
7868	8160	});
7869	8161
7870		cases.add("aligned variable of zero-bit type",
	8162	ctx.objErrStage1("aligned variable of zero-bit type",
7871	8163	\\export fn f() void {
7872	8164	\\ var s: struct {} align(4) = undefined;
	8165	\\ _ = s;
7873	8166	\\}
7874	8167	, &[_][]const u8{
7875	8168	"tmp.zig:2:5: error: variable 's' of zero-bit type 'struct:2:12' has no in-memory representation, it cannot be aligned",
7876	8169	});
7877	8170
7878		cases.add("function returning opaque type",
	8171	ctx.objErrStage1("function returning opaque type",
7879	8172	\\const FooType = opaque {};
7880	8173	\\export fn bar() !FooType {
7881	8174	\\ return error.InvalidValue;
...	...	@@ -7893,7 +8186,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7893	8186	"tmp.zig:8:18: error: Undefined return type '(undefined)' not allowed",
7894	8187	});
7895	8188
7896		cases.add("generic function returning opaque type",
	8189	ctx.objErrStage1("generic function returning opaque type",
7897	8190	\\const FooType = opaque {};
7898	8191	\\fn generic(comptime T: type) !T {
7899	8192	\\ return undefined;
...	...	@@ -7917,81 +8210,89 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7917	8210	"tmp.zig:2:1: note: function declared here",
7918	8211	});
7919	8212
7920		cases.add("function parameter is opaque",
	8213	ctx.objErrStage1("function parameter is opaque",
7921	8214	\\const FooType = opaque {};
7922	8215	\\export fn entry1() void {
7923	8216	\\ const someFuncPtr: fn (FooType) void = undefined;
	8217	\\ _ = someFuncPtr;
7924	8218	\\}
7925	8219	\\
7926	8220	\\export fn entry2() void {
7927	8221	\\ const someFuncPtr: fn (@TypeOf(null)) void = undefined;
	8222	\\ _ = someFuncPtr;
7928	8223	\\}
7929	8224	\\
7930		\\fn foo(p: FooType) void {}
	8225	\\fn foo(p: FooType) void {_ = p;}
7931	8226	\\export fn entry3() void {
7932	8227	\\ _ = foo;
7933	8228	\\}
7934	8229	\\
7935		\\fn bar(p: @TypeOf(null)) void {}
	8230	\\fn bar(p: @TypeOf(null)) void {_ = p;}
7936	8231	\\export fn entry4() void {
7937	8232	\\ _ = bar;
7938	8233	\\}
7939	8234	, &[_][]const u8{
7940	8235	"tmp.zig:3:28: error: parameter of opaque type 'FooType' not allowed",
7941		"tmp.zig:7:28: error: parameter of type '(null)' not allowed",
7942		"tmp.zig:10:11: error: parameter of opaque type 'FooType' not allowed",
7943		"tmp.zig:15:11: error: parameter of type '(null)' not allowed",
	8236	"tmp.zig:8:28: error: parameter of type '(null)' not allowed",
	8237	"tmp.zig:12:11: error: parameter of opaque type 'FooType' not allowed",
	8238	"tmp.zig:17:11: error: parameter of type '(null)' not allowed",
7944	8239	});
7945	8240
7946		cases.add( // fixed bug #2032
	8241	ctx.objErrStage1( // fixed bug #2032
7947	8242	"compile diagnostic string for top level decl type",
7948	8243	\\export fn entry() void {
7949	8244	\\ var foo: u32 = @This(){};
	8245	\\ _ = foo;
7950	8246	\\}
7951	8247	, &[_][]const u8{
7952	8248	"tmp.zig:2:27: error: type 'u32' does not support array initialization",
7953	8249	});
7954	8250
7955		cases.add("issue #2687: coerce from undefined array pointer to slice",
	8251	ctx.objErrStage1("issue #2687: coerce from undefined array pointer to slice",
7956	8252	\\export fn foo1() void {
7957	8253	\\ const a: *[1]u8 = undefined;
7958	8254	\\ var b: []u8 = a;
	8255	\\ _ = b;
7959	8256	\\}
7960	8257	\\export fn foo2() void {
7961	8258	\\ comptime {
7962	8259	\\ var a: *[1]u8 = undefined;
7963	8260	\\ var b: []u8 = a;
	8261	\\ _ = b;
7964	8262	\\ }
7965	8263	\\}
7966	8264	\\export fn foo3() void {
7967	8265	\\ comptime {
7968	8266	\\ const a: *[1]u8 = undefined;
7969	8267	\\ var b: []u8 = a;
	8268	\\ _ = b;
7970	8269	\\ }
7971	8270	\\}
7972	8271	, &[_][]const u8{
7973	8272	"tmp.zig:3:19: error: use of undefined value here causes undefined behavior",
7974		"tmp.zig:8:23: error: use of undefined value here causes undefined behavior",
7975		"tmp.zig:14:23: error: use of undefined value here causes undefined behavior",
	8273	"tmp.zig:9:23: error: use of undefined value here causes undefined behavior",
	8274	"tmp.zig:16:23: error: use of undefined value here causes undefined behavior",
7976	8275	});
7977	8276
7978		cases.add("issue #3818: bitcast from parray/slice to u16",
	8277	ctx.objErrStage1("issue #3818: bitcast from parray/slice to u16",
7979	8278	\\export fn foo1() void {
7980	8279	\\ var bytes = [_]u8{1, 2};
7981	8280	\\ const word: u16 = @bitCast(u16, bytes[0..]);
	8281	\\ _ = word;
7982	8282	\\}
7983	8283	\\export fn foo2() void {
7984	8284	\\ var bytes: []const u8 = &[_]u8{1, 2};
7985	8285	\\ const word: u16 = @bitCast(u16, bytes);
	8286	\\ _ = word;
7986	8287	\\}
7987	8288	, &[_][]const u8{
7988	8289	"tmp.zig:3:42: error: unable to @bitCast from pointer type '*[2]u8'",
7989		"tmp.zig:7:32: error: destination type 'u16' has size 2 but source type '[]const u8' has size 16",
7990		"tmp.zig:7:37: note: referenced here",
	8290	"tmp.zig:8:32: error: destination type 'u16' has size 2 but source type '[]const u8' has size 16",
	8291	"tmp.zig:8:37: note: referenced here",
7991	8292	});
7992	8293
7993	8294	// issue #7810
7994		cases.add("comptime slice-len increment beyond bounds",
	8295	ctx.objErrStage1("comptime slice-len increment beyond bounds",
7995	8296	\\export fn foo_slice_len_increment_beyond_bounds() void {
7996	8297	\\ comptime {
7997	8298	\\ var buf_storage: [8]u8 = undefined;
...	...	@@ -8004,11 +8305,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8004	8305	":6:12: error: out of bounds slice",
8005	8306	});
8006	8307
8007		cases.add("comptime slice-sentinel is out of bounds (unterminated)",
	8308	ctx.objErrStage1("comptime slice-sentinel is out of bounds (unterminated)",
8008	8309	\\export fn foo_array() void {
8009	8310	\\ comptime {
8010	8311	\\ var target = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8011	8312	\\ const slice = target[0..14 :0];
	8313	\\ _ = slice;
8012	8314	\\ }
8013	8315	\\}
8014	8316	\\export fn foo_ptr_array() void {
...	...	@@ -8016,6 +8318,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8016	8318	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8017	8319	\\ var target = &buf;
8018	8320	\\ const slice = target[0..14 :0];
	8321	\\ _ = slice;
8019	8322	\\ }
8020	8323	\\}
8021	8324	\\export fn foo_vector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8023,6 +8326,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8023	8326	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8024	8327	\\ var target: [*]u8 = &buf;
8025	8328	\\ const slice = target[0..14 :0];
	8329	\\ _ = slice;
8026	8330	\\ }
8027	8331	\\}
8028	8332	\\export fn foo_vector_ConstPtrSpecialRef() void {
...	...	@@ -8030,6 +8334,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8030	8334	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8031	8335	\\ var target: []u8 = @ptrCast([]u8, &buf);
8032	8336	\\ const slice = target[0..14 :0];
	8337	\\ _ = slice;
8033	8338	\\ }
8034	8339	\\}
8035	8340	\\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8037,6 +8342,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8037	8342	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8038	8343	\\ var target: [*c]u8 = &buf;
8039	8344	\\ const slice = target[0..14 :0];
	8345	\\ _ = slice;
8040	8346	\\ }
8041	8347	\\}
8042	8348	\\export fn foo_cvector_ConstPtrSpecialRef() void {
...	...	@@ -8044,6 +8350,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8044	8350	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8045	8351	\\ var target: [c]u8 = @ptrCast([c]u8, &buf);
8046	8352	\\ const slice = target[0..14 :0];
	8353	\\ _ = slice;
8047	8354	\\ }
8048	8355	\\}
8049	8356	\\export fn foo_slice() void {
...	...	@@ -8051,23 +8358,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8051	8358	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8052	8359	\\ var target: []u8 = &buf;
8053	8360	\\ const slice = target[0..14 :0];
	8361	\\ _ = slice;
8054	8362	\\ }
8055	8363	\\}
8056	8364	, &[_][]const u8{
8057	8365	":4:29: error: slice-sentinel is out of bounds",
8058		":11:29: error: slice-sentinel is out of bounds",
8059		":18:29: error: slice-sentinel is out of bounds",
8060		":25:29: error: slice-sentinel is out of bounds",
8061		":32:29: error: slice-sentinel is out of bounds",
8062		":39:29: error: slice-sentinel is out of bounds",
8063		":46:29: error: slice-sentinel is out of bounds",
	8366	":12:29: error: slice-sentinel is out of bounds",
	8367	":20:29: error: slice-sentinel is out of bounds",
	8368	":28:29: error: slice-sentinel is out of bounds",
	8369	":36:29: error: slice-sentinel is out of bounds",
	8370	":44:29: error: slice-sentinel is out of bounds",
	8371	":52:29: error: slice-sentinel is out of bounds",
8064	8372	});
8065	8373
8066		cases.add("comptime slice-sentinel is out of bounds (terminated)",
	8374	ctx.objErrStage1("comptime slice-sentinel is out of bounds (terminated)",
8067	8375	\\export fn foo_array() void {
8068	8376	\\ comptime {
8069	8377	\\ var target = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8070	8378	\\ const slice = target[0..15 :1];
	8379	\\ _ = slice;
8071	8380	\\ }
8072	8381	\\}
8073	8382	\\export fn foo_ptr_array() void {
...	...	@@ -8075,6 +8384,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8075	8384	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8076	8385	\\ var target = &buf;
8077	8386	\\ const slice = target[0..15 :0];
	8387	\\ _ = slice;
8078	8388	\\ }
8079	8389	\\}
8080	8390	\\export fn foo_vector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8082,6 +8392,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8082	8392	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8083	8393	\\ var target: [*]u8 = &buf;
8084	8394	\\ const slice = target[0..15 :0];
	8395	\\ _ = slice;
8085	8396	\\ }
8086	8397	\\}
8087	8398	\\export fn foo_vector_ConstPtrSpecialRef() void {
...	...	@@ -8089,6 +8400,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8089	8400	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8090	8401	\\ var target: []u8 = @ptrCast([]u8, &buf);
8091	8402	\\ const slice = target[0..15 :0];
	8403	\\ _ = slice;
8092	8404	\\ }
8093	8405	\\}
8094	8406	\\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8096,6 +8408,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8096	8408	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8097	8409	\\ var target: [*c]u8 = &buf;
8098	8410	\\ const slice = target[0..15 :0];
	8411	\\ _ = slice;
8099	8412	\\ }
8100	8413	\\}
8101	8414	\\export fn foo_cvector_ConstPtrSpecialRef() void {
...	...	@@ -8103,6 +8416,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8103	8416	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8104	8417	\\ var target: [c]u8 = @ptrCast([c]u8, &buf);
8105	8418	\\ const slice = target[0..15 :0];
	8419	\\ _ = slice;
8106	8420	\\ }
8107	8421	\\}
8108	8422	\\export fn foo_slice() void {
...	...	@@ -8110,23 +8424,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8110	8424	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8111	8425	\\ var target: []u8 = &buf;
8112	8426	\\ const slice = target[0..15 :0];
	8427	\\ _ = slice;
8113	8428	\\ }
8114	8429	\\}
8115	8430	, &[_][]const u8{
8116	8431	":4:29: error: out of bounds slice",
8117		":11:29: error: out of bounds slice",
8118		":18:29: error: out of bounds slice",
8119		":25:29: error: out of bounds slice",
8120		":32:29: error: out of bounds slice",
8121		":39:29: error: out of bounds slice",
8122		":46:29: error: out of bounds slice",
	8432	":12:29: error: out of bounds slice",
	8433	":20:29: error: out of bounds slice",
	8434	":28:29: error: out of bounds slice",
	8435	":36:29: error: out of bounds slice",
	8436	":44:29: error: out of bounds slice",
	8437	":52:29: error: out of bounds slice",
8123	8438	});
8124	8439
8125		cases.add("comptime slice-sentinel does not match memory at target index (unterminated)",
	8440	ctx.objErrStage1("comptime slice-sentinel does not match memory at target index (unterminated)",
8126	8441	\\export fn foo_array() void {
8127	8442	\\ comptime {
8128	8443	\\ var target = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8129	8444	\\ const slice = target[0..3 :0];
	8445	\\ _ = slice;
8130	8446	\\ }
8131	8447	\\}
8132	8448	\\export fn foo_ptr_array() void {
...	...	@@ -8134,6 +8450,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8134	8450	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8135	8451	\\ var target = &buf;
8136	8452	\\ const slice = target[0..3 :0];
	8453	\\ _ = slice;
8137	8454	\\ }
8138	8455	\\}
8139	8456	\\export fn foo_vector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8141,6 +8458,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8141	8458	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8142	8459	\\ var target: [*]u8 = &buf;
8143	8460	\\ const slice = target[0..3 :0];
	8461	\\ _ = slice;
8144	8462	\\ }
8145	8463	\\}
8146	8464	\\export fn foo_vector_ConstPtrSpecialRef() void {
...	...	@@ -8148,6 +8466,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8148	8466	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8149	8467	\\ var target: []u8 = @ptrCast([]u8, &buf);
8150	8468	\\ const slice = target[0..3 :0];
	8469	\\ _ = slice;
8151	8470	\\ }
8152	8471	\\}
8153	8472	\\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8155,6 +8474,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8155	8474	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8156	8475	\\ var target: [*c]u8 = &buf;
8157	8476	\\ const slice = target[0..3 :0];
	8477	\\ _ = slice;
8158	8478	\\ }
8159	8479	\\}
8160	8480	\\export fn foo_cvector_ConstPtrSpecialRef() void {
...	...	@@ -8162,6 +8482,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8162	8482	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8163	8483	\\ var target: [c]u8 = @ptrCast([c]u8, &buf);
8164	8484	\\ const slice = target[0..3 :0];
	8485	\\ _ = slice;
8165	8486	\\ }
8166	8487	\\}
8167	8488	\\export fn foo_slice() void {
...	...	@@ -8169,23 +8490,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8169	8490	\\ var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8170	8491	\\ var target: []u8 = &buf;
8171	8492	\\ const slice = target[0..3 :0];
	8493	\\ _ = slice;
8172	8494	\\ }
8173	8495	\\}
8174	8496	, &[_][]const u8{
8175	8497	":4:29: error: slice-sentinel does not match memory at target index",
8176		":11:29: error: slice-sentinel does not match memory at target index",
8177		":18:29: error: slice-sentinel does not match memory at target index",
8178		":25:29: error: slice-sentinel does not match memory at target index",
8179		":32:29: error: slice-sentinel does not match memory at target index",
8180		":39:29: error: slice-sentinel does not match memory at target index",
8181		":46:29: error: slice-sentinel does not match memory at target index",
	8498	":12:29: error: slice-sentinel does not match memory at target index",
	8499	":20:29: error: slice-sentinel does not match memory at target index",
	8500	":28:29: error: slice-sentinel does not match memory at target index",
	8501	":36:29: error: slice-sentinel does not match memory at target index",
	8502	":44:29: error: slice-sentinel does not match memory at target index",
	8503	":52:29: error: slice-sentinel does not match memory at target index",
8182	8504	});
8183	8505
8184		cases.add("comptime slice-sentinel does not match memory at target index (terminated)",
	8506	ctx.objErrStage1("comptime slice-sentinel does not match memory at target index (terminated)",
8185	8507	\\export fn foo_array() void {
8186	8508	\\ comptime {
8187	8509	\\ var target = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8188	8510	\\ const slice = target[0..3 :0];
	8511	\\ _ = slice;
8189	8512	\\ }
8190	8513	\\}
8191	8514	\\export fn foo_ptr_array() void {
...	...	@@ -8193,6 +8516,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8193	8516	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8194	8517	\\ var target = &buf;
8195	8518	\\ const slice = target[0..3 :0];
	8519	\\ _ = slice;
8196	8520	\\ }
8197	8521	\\}
8198	8522	\\export fn foo_vector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8200,6 +8524,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8200	8524	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8201	8525	\\ var target: [*]u8 = &buf;
8202	8526	\\ const slice = target[0..3 :0];
	8527	\\ _ = slice;
8203	8528	\\ }
8204	8529	\\}
8205	8530	\\export fn foo_vector_ConstPtrSpecialRef() void {
...	...	@@ -8207,6 +8532,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8207	8532	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8208	8533	\\ var target: []u8 = @ptrCast([]u8, &buf);
8209	8534	\\ const slice = target[0..3 :0];
	8535	\\ _ = slice;
8210	8536	\\ }
8211	8537	\\}
8212	8538	\\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8214,6 +8540,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8214	8540	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8215	8541	\\ var target: [*c]u8 = &buf;
8216	8542	\\ const slice = target[0..3 :0];
	8543	\\ _ = slice;
8217	8544	\\ }
8218	8545	\\}
8219	8546	\\export fn foo_cvector_ConstPtrSpecialRef() void {
...	...	@@ -8221,6 +8548,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8221	8548	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8222	8549	\\ var target: [c]u8 = @ptrCast([c]u8, &buf);
8223	8550	\\ const slice = target[0..3 :0];
	8551	\\ _ = slice;
8224	8552	\\ }
8225	8553	\\}
8226	8554	\\export fn foo_slice() void {
...	...	@@ -8228,23 +8556,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8228	8556	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8229	8557	\\ var target: []u8 = &buf;
8230	8558	\\ const slice = target[0..3 :0];
	8559	\\ _ = slice;
8231	8560	\\ }
8232	8561	\\}
8233	8562	, &[_][]const u8{
8234	8563	":4:29: error: slice-sentinel does not match memory at target index",
8235		":11:29: error: slice-sentinel does not match memory at target index",
8236		":18:29: error: slice-sentinel does not match memory at target index",
8237		":25:29: error: slice-sentinel does not match memory at target index",
8238		":32:29: error: slice-sentinel does not match memory at target index",
8239		":39:29: error: slice-sentinel does not match memory at target index",
8240		":46:29: error: slice-sentinel does not match memory at target index",
	8564	":12:29: error: slice-sentinel does not match memory at target index",
	8565	":20:29: error: slice-sentinel does not match memory at target index",
	8566	":28:29: error: slice-sentinel does not match memory at target index",
	8567	":36:29: error: slice-sentinel does not match memory at target index",
	8568	":44:29: error: slice-sentinel does not match memory at target index",
	8569	":52:29: error: slice-sentinel does not match memory at target index",
8241	8570	});
8242	8571
8243		cases.add("comptime slice-sentinel does not match target-sentinel",
	8572	ctx.objErrStage1("comptime slice-sentinel does not match target-sentinel",
8244	8573	\\export fn foo_array() void {
8245	8574	\\ comptime {
8246	8575	\\ var target = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8247	8576	\\ const slice = target[0..14 :255];
	8577	\\ _ = slice;
8248	8578	\\ }
8249	8579	\\}
8250	8580	\\export fn foo_ptr_array() void {
...	...	@@ -8252,6 +8582,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8252	8582	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8253	8583	\\ var target = &buf;
8254	8584	\\ const slice = target[0..14 :255];
	8585	\\ _ = slice;
8255	8586	\\ }
8256	8587	\\}
8257	8588	\\export fn foo_vector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8259,6 +8590,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8259	8590	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8260	8591	\\ var target: [*]u8 = &buf;
8261	8592	\\ const slice = target[0..14 :255];
	8593	\\ _ = slice;
8262	8594	\\ }
8263	8595	\\}
8264	8596	\\export fn foo_vector_ConstPtrSpecialRef() void {
...	...	@@ -8266,6 +8598,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8266	8598	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8267	8599	\\ var target: []u8 = @ptrCast([]u8, &buf);
8268	8600	\\ const slice = target[0..14 :255];
	8601	\\ _ = slice;
8269	8602	\\ }
8270	8603	\\}
8271	8604	\\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
...	...	@@ -8273,6 +8606,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8273	8606	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8274	8607	\\ var target: [*c]u8 = &buf;
8275	8608	\\ const slice = target[0..14 :255];
	8609	\\ _ = slice;
8276	8610	\\ }
8277	8611	\\}
8278	8612	\\export fn foo_cvector_ConstPtrSpecialRef() void {
...	...	@@ -8280,6 +8614,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8280	8614	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8281	8615	\\ var target: [c]u8 = @ptrCast([c]u8, &buf);
8282	8616	\\ const slice = target[0..14 :255];
	8617	\\ _ = slice;
8283	8618	\\ }
8284	8619	\\}
8285	8620	\\export fn foo_slice() void {
...	...	@@ -8287,19 +8622,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8287	8622	\\ var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
8288	8623	\\ var target: []u8 = &buf;
8289	8624	\\ const slice = target[0..14 :255];
	8625	\\ _ = slice;
8290	8626	\\ }
8291	8627	\\}
8292	8628	, &[_][]const u8{
8293	8629	":4:29: error: slice-sentinel does not match target-sentinel",
8294		":11:29: error: slice-sentinel does not match target-sentinel",
8295		":18:29: error: slice-sentinel does not match target-sentinel",
8296		":25:29: error: slice-sentinel does not match target-sentinel",
8297		":32:29: error: slice-sentinel does not match target-sentinel",
8298		":39:29: error: slice-sentinel does not match target-sentinel",
8299		":46:29: error: slice-sentinel does not match target-sentinel",
	8630	":12:29: error: slice-sentinel does not match target-sentinel",
	8631	":20:29: error: slice-sentinel does not match target-sentinel",
	8632	":28:29: error: slice-sentinel does not match target-sentinel",
	8633	":36:29: error: slice-sentinel does not match target-sentinel",
	8634	":44:29: error: slice-sentinel does not match target-sentinel",
	8635	":52:29: error: slice-sentinel does not match target-sentinel",
8300	8636	});
8301	8637
8302		cases.add("issue #4207: coerce from non-terminated-slice to terminated-pointer",
	8638	ctx.objErrStage1("issue #4207: coerce from non-terminated-slice to terminated-pointer",
8303	8639	\\export fn foo() [*:0]const u8 {
8304	8640	\\ var buffer: [64]u8 = undefined;
8305	8641	\\ return buffer[0..];
...	...	@@ -8309,8 +8645,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8309	8645	":3:18: note: destination pointer requires a terminating '0' sentinel",
8310	8646	});
8311	8647
8312		cases.add("issue #5221: invalid struct init type referenced by @typeInfo and passed into function",
8313		\\fn ignore(comptime param: anytype) void {}
	8648	ctx.objErrStage1("issue #5221: invalid struct init type referenced by @typeInfo and passed into function",
	8649	\\fn ignore(comptime param: anytype) void {_ = param;}
8314	8650	\\
8315	8651	\\export fn foo() void {
8316	8652	\\ const MyStruct = struct {
...	...	@@ -8323,7 +8659,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8323	8659	":5:28: error: expected type '[]u8', found '*const [3:0]u8'",
8324	8660	});
8325	8661
8326		cases.add("integer underflow error",
	8662	ctx.objErrStage1("integer underflow error",
8327	8663	\\export fn entry() void {
8328	8664	\\ _ = @intToPtr(*c_void, ~@as(usize, @import("std").math.maxInt(usize)) - 1);
8329	8665	\\}
...	...	@@ -8331,23 +8667,24 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8331	8667	":2:75: error: operation caused overflow",
8332	8668	});
8333	8669
8334		cases.addCase(x: {
8335		var tc = cases.create("align(N) expr function pointers is a compile error",
	8670	{
	8671	const case = ctx.obj("align(N) expr function pointers is a compile error", .{
	8672	.cpu_arch = .wasm32,
	8673	.os_tag = .freestanding,
	8674	.abi = .none,
	8675	});
	8676	case.backend = .stage1;
	8677
	8678	case.addError(
8336	8679	\\export fn foo() align(1) void {
8337	8680	\\ return;
8338	8681	\\}
8339	8682	, &[_][]const u8{
8340	8683	"tmp.zig:1:23: error: align(N) expr is not allowed on function prototypes in wasm32/wasm64",
8341	8684	});
8342		tc.target = std.zig.CrossTarget{
8343		.cpu_arch = .wasm32,
8344		.os_tag = .freestanding,
8345		.abi = .none,
8346		};
8347		break :x tc;
8348		});
	8685	}
8349	8686
8350		cases.add("compare optional to non-optional with invalid types",
	8687	ctx.objErrStage1("compare optional to non-optional with invalid types",
8351	8688	\\export fn inconsistentChildType() void {
8352	8689	\\ var x: ?i32 = undefined;
8353	8690	\\ const y: comptime_int = 10;
...	...	@@ -8381,16 +8718,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8381	8718	":22:12: note: operator not supported for type '[3]i32'",
8382	8719	});
8383	8720
8384		cases.add("slice cannot have its bytes reinterpreted",
	8721	ctx.objErrStage1("slice cannot have its bytes reinterpreted",
8385	8722	\\export fn foo() void {
8386	8723	\\ const bytes = [1]u8{ 0xfa } ** 16;
8387	8724	\\ var value = @ptrCast(const []const u8, &bytes).;
	8725	\\ _ = value;
8388	8726	\\}
8389	8727	, &[_][]const u8{
8390	8728	":3:52: error: slice '[]const u8' cannot have its bytes reinterpreted",
8391	8729	});
8392	8730
8393		cases.add("wasmMemorySize is a compile error in non-Wasm targets",
	8731	ctx.objErrStage1("wasmMemorySize is a compile error in non-Wasm targets",
8394	8732	\\export fn foo() void {
8395	8733	\\ _ = @wasmMemorySize(0);
8396	8734	\\ return;
...	...	@@ -8399,7 +8737,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8399	8737	"tmp.zig:2:9: error: @wasmMemorySize is a wasm32 feature only",
8400	8738	});
8401	8739
8402		cases.add("wasmMemoryGrow is a compile error in non-Wasm targets",
	8740	ctx.objErrStage1("wasmMemoryGrow is a compile error in non-Wasm targets",
8403	8741	\\export fn foo() void {
8404	8742	\\ _ = @wasmMemoryGrow(0, 1);
8405	8743	\\ return;
...	...	@@ -8407,7 +8745,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8407	8745	, &[_][]const u8{
8408	8746	"tmp.zig:2:9: error: @wasmMemoryGrow is a wasm32 feature only",
8409	8747	});
8410		cases.add("Issue #5586: Make unary minus for unsigned types a compile error",
	8748	ctx.objErrStage1("Issue #5586: Make unary minus for unsigned types a compile error",
8411	8749	\\export fn f1(x: u32) u32 {
8412	8750	\\ const y = -%x;
8413	8751	\\ return -y;
...	...	@@ -8422,7 +8760,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8422	8760	"tmp.zig:8:12: error: negation of type 'u32'",
8423	8761	});
8424	8762
8425		cases.add("Issue #5618: coercion of ?c_void to c_void must fail.",
	8763	ctx.objErrStage1("Issue #5618: coercion of ?c_void to c_void must fail.",
8426	8764	\\export fn foo() void {
8427	8765	\\ var u: ?*c_void = null;
8428	8766	\\ var v: *c_void = undefined;
...	...	@@ -8432,15 +8770,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
8432	8770	"tmp.zig:4:9: error: expected type 'c_void', found '?c_void'",
8433	8771	});
8434	8772
8435		cases.add("Issue #6823: don't allow .* to be followed by **",
	8773	ctx.objErrStage1("Issue #6823: don't allow .* to be followed by **",
8436	8774	\\fn foo() void {
8437	8775	\\ var sequence = "repeat".*** 10;
	8776	\\ _ = sequence;
8438	8777	\\}
8439	8778	, &[_][]const u8{
8440		"tmp.zig:2:30: error: `.` cannot be followed by ``. Are you missing a space?",
	8779	// Ideally this would be column 30 but it's not very important.
	8780	"tmp.zig:2:28: error: '.' cannot be followed by ''. Are you missing a space?",
8441	8781	});
8442	8782
8443		cases.add("Issue #9165: windows tcp server compilation error",
	8783	ctx.objErrStage1("Issue #9165: windows tcp server compilation error",
8444	8784	\\const std = @import("std");
8445	8785	\\pub const io_mode = .evented;
8446	8786	\\pub fn main() !void {

test/stage2/cbe.zig+7-6

...	...	@@ -525,7 +525,7 @@ pub fn addCases(ctx: *TestContext) !void {
525	525	\\}
526	526	, &.{
527	527	":3:21: error: missing struct field: x",
528		":1:15: note: struct 'test_case.Point' declared here",
	528	":1:15: note: struct 'tmp.Point' declared here",
529	529	});
530	530	case.addError(
531	531	\\const Point = struct { x: i32, y: i32 };
...	...	@@ -538,7 +538,7 @@ pub fn addCases(ctx: *TestContext) !void {
538	538	\\ return p.y - p.x - p.x;
539	539	\\}
540	540	, &.{
541		":6:10: error: no field named 'z' in struct 'test_case.Point'",
	541	":6:10: error: no field named 'z' in struct 'tmp.Point'",
542	542	":1:15: note: struct declared here",
543	543	});
544	544	case.addCompareOutput(
...	...	@@ -591,6 +591,7 @@ pub fn addCases(ctx: *TestContext) !void {
591	591	, &.{
592	592	":3:5: error: enum fields cannot be marked comptime",
593	593	":8:8: error: enum fields do not have types",
	594	":6:12: note: consider 'union(enum)' here to make it a tagged union",
594	595	});
595	596
596	597	// @enumToInt, @intToEnum, enum literal coercion, field access syntax, comparison, switch
...	...	@@ -716,7 +717,7 @@ pub fn addCases(ctx: *TestContext) !void {
716	717	\\ _ = @intToEnum(E, 3);
717	718	\\}
718	719	, &.{
719		":3:9: error: enum 'test_case.E' has no tag with value 3",
	720	":3:9: error: enum 'tmp.E' has no tag with value 3",
720	721	":1:11: note: enum declared here",
721	722	});
722	723
...	...	@@ -732,7 +733,7 @@ pub fn addCases(ctx: *TestContext) !void {
732	733	, &.{
733	734	":4:5: error: switch must handle all possibilities",
734	735	":4:5: note: unhandled enumeration value: 'b'",
735		":1:11: note: enum 'test_case.E' declared here",
	736	":1:11: note: enum 'tmp.E' declared here",
736	737	});
737	738
738	739	case.addError(
...	...	@@ -787,7 +788,7 @@ pub fn addCases(ctx: *TestContext) !void {
787	788	\\ _ = E.d;
788	789	\\}
789	790	, &.{
790		":3:10: error: enum 'test_case.E' has no member named 'd'",
	791	":3:10: error: enum 'tmp.E' has no member named 'd'",
791	792	":1:11: note: enum declared here",
792	793	});
793	794
...	...	@@ -798,7 +799,7 @@ pub fn addCases(ctx: *TestContext) !void {
798	799	\\ _ = x;
799	800	\\}
800	801	, &.{
801		":3:17: error: enum 'test_case.E' has no field named 'd'",
	802	":3:17: error: enum 'tmp.E' has no field named 'd'",
802	803	":1:11: note: enum declared here",
803	804	});
804	805	}

test/stage2/darwin.zig+1-1

...	...	@@ -14,7 +14,7 @@ pub fn addCases(ctx: *TestContext) !void {
14	14	{
15	15	var case = ctx.exe("hello world with updates", target);
16	16	case.addError("", &[_][]const u8{
17		":93:9: error: struct 'test_case.test_case' has no member named 'main'",
	17	":93:9: error: struct 'tmp.tmp' has no member named 'main'",
18	18	});
19	19
20	20	// Incorrect return type

test/stage2/test.zig deleted-1626

...	...	@@ -1,1626 +0,0 @@
1		const std = @import("std");
2		const TestContext = @import("../../src/test.zig").TestContext;
3
4		// Self-hosted has differing levels of support for various architectures. For now we pass explicit
5		// target parameters to each test case. At some point we will take this to the next level and have
6		// a set of targets that all test cases run on unless specifically overridden. For now, each test
7		// case applies to only the specified target.
8
9		const linux_x64 = std.zig.CrossTarget{
10		.cpu_arch = .x86_64,
11		.os_tag = .linux,
12		};
13
14		pub fn addCases(ctx: *TestContext) !void {
15		try @import("cbe.zig").addCases(ctx);
16		try @import("arm.zig").addCases(ctx);
17		try @import("aarch64.zig").addCases(ctx);
18		try @import("llvm.zig").addCases(ctx);
19		try @import("wasm.zig").addCases(ctx);
20		try @import("darwin.zig").addCases(ctx);
21		try @import("riscv64.zig").addCases(ctx);
22
23		{
24		var case = ctx.exe("hello world with updates", linux_x64);
25
26		case.addError("", &[_][]const u8{
27		":93:9: error: struct 'test_case.test_case' has no member named 'main'",
28		});
29
30		// Incorrect return type
31		case.addError(
32		\\pub export fn _start() noreturn {
33		\\}
34		, &[_][]const u8{":2:1: error: expected noreturn, found void"});
35
36		// Regular old hello world
37		case.addCompareOutput(
38		\\pub export fn _start() noreturn {
39		\\ print();
40		\\
41		\\ exit();
42		\\}
43		\\
44		\\fn print() void {
45		\\ asm volatile ("syscall"
46		\\ :
47		\\ : [number] "{rax}" (1),
48		\\ [arg1] "{rdi}" (1),
49		\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
50		\\ [arg3] "{rdx}" (14)
51		\\ : "rcx", "r11", "memory"
52		\\ );
53		\\ return;
54		\\}
55		\\
56		\\fn exit() noreturn {
57		\\ asm volatile ("syscall"
58		\\ :
59		\\ : [number] "{rax}" (231),
60		\\ [arg1] "{rdi}" (0)
61		\\ : "rcx", "r11", "memory"
62		\\ );
63		\\ unreachable;
64		\\}
65		,
66		"Hello, World!\n",
67		);
68
69		// Convert to pub fn main
70		case.addCompareOutput(
71		\\pub fn main() void {
72		\\ print();
73		\\}
74		\\
75		\\fn print() void {
76		\\ asm volatile ("syscall"
77		\\ :
78		\\ : [number] "{rax}" (1),
79		\\ [arg1] "{rdi}" (1),
80		\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
81		\\ [arg3] "{rdx}" (14)
82		\\ : "rcx", "r11", "memory"
83		\\ );
84		\\ return;
85		\\}
86		,
87		"Hello, World!\n",
88		);
89
90		// Now change the message only
91		case.addCompareOutput(
92		\\pub fn main() void {
93		\\ print();
94		\\}
95		\\
96		\\fn print() void {
97		\\ asm volatile ("syscall"
98		\\ :
99		\\ : [number] "{rax}" (1),
100		\\ [arg1] "{rdi}" (1),
101		\\ [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
102		\\ [arg3] "{rdx}" (104)
103		\\ : "rcx", "r11", "memory"
104		\\ );
105		\\ return;
106		\\}
107		,
108		"What is up? This is a longer message that will force the data to be relocated in virtual address space.\n",
109		);
110		// Now we print it twice.
111		case.addCompareOutput(
112		\\pub fn main() void {
113		\\ print();
114		\\ print();
115		\\}
116		\\
117		\\fn print() void {
118		\\ asm volatile ("syscall"
119		\\ :
120		\\ : [number] "{rax}" (1),
121		\\ [arg1] "{rdi}" (1),
122		\\ [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
123		\\ [arg3] "{rdx}" (104)
124		\\ : "rcx", "r11", "memory"
125		\\ );
126		\\ return;
127		\\}
128		,
129		\\What is up? This is a longer message that will force the data to be relocated in virtual address space.
130		\\What is up? This is a longer message that will force the data to be relocated in virtual address space.
131		\\
132		);
133		}
134
135		{
136		var case = ctx.exe("adding numbers at comptime", linux_x64);
137		case.addCompareOutput(
138		\\pub export fn _start() noreturn {
139		\\ asm volatile ("syscall"
140		\\ :
141		\\ : [number] "{rax}" (1),
142		\\ [arg1] "{rdi}" (1),
143		\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
144		\\ [arg3] "{rdx}" (10 + 4)
145		\\ : "rcx", "r11", "memory"
146		\\ );
147		\\ asm volatile ("syscall"
148		\\ :
149		\\ : [number] "{rax}" (@as(usize, 230) + @as(usize, 1)),
150		\\ [arg1] "{rdi}" (0)
151		\\ : "rcx", "r11", "memory"
152		\\ );
153		\\ unreachable;
154		\\}
155		,
156		"Hello, World!\n",
157		);
158		}
159
160		{
161		var case = ctx.exe("adding numbers at runtime and comptime", linux_x64);
162		case.addCompareOutput(
163		\\pub export fn _start() noreturn {
164		\\ add(3, 4);
165		\\
166		\\ exit();
167		\\}
168		\\
169		\\fn add(a: u32, b: u32) void {
170		\\ if (a + b != 7) unreachable;
171		\\}
172		\\
173		\\fn exit() noreturn {
174		\\ asm volatile ("syscall"
175		\\ :
176		\\ : [number] "{rax}" (231),
177		\\ [arg1] "{rdi}" (0)
178		\\ : "rcx", "r11", "memory"
179		\\ );
180		\\ unreachable;
181		\\}
182		,
183		"",
184		);
185		// comptime function call
186		case.addCompareOutput(
187		\\pub export fn _start() noreturn {
188		\\ exit();
189		\\}
190		\\
191		\\fn add(a: u32, b: u32) u32 {
192		\\ return a + b;
193		\\}
194		\\
195		\\const x = add(3, 4);
196		\\
197		\\fn exit() noreturn {
198		\\ asm volatile ("syscall"
199		\\ :
200		\\ : [number] "{rax}" (231),
201		\\ [arg1] "{rdi}" (x - 7)
202		\\ : "rcx", "r11", "memory"
203		\\ );
204		\\ unreachable;
205		\\}
206		,
207		"",
208		);
209		// Inline function call
210		case.addCompareOutput(
211		\\pub export fn _start() noreturn {
212		\\ var x: usize = 3;
213		\\ const y = add(1, 2, x);
214		\\ exit(y - 6);
215		\\}
216		\\
217		\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
218		\\ return a + b + c;
219		\\}
220		\\
221		\\fn exit(code: usize) noreturn {
222		\\ asm volatile ("syscall"
223		\\ :
224		\\ : [number] "{rax}" (231),
225		\\ [arg1] "{rdi}" (code)
226		\\ : "rcx", "r11", "memory"
227		\\ );
228		\\ unreachable;
229		\\}
230		,
231		"",
232		);
233		}
234
235		{
236		var case = ctx.exe("subtracting numbers at runtime", linux_x64);
237		case.addCompareOutput(
238		\\pub fn main() void {
239		\\ sub(7, 4);
240		\\}
241		\\
242		\\fn sub(a: u32, b: u32) void {
243		\\ if (a - b != 3) unreachable;
244		\\}
245		,
246		"",
247		);
248		}
249		{
250		var case = ctx.exe("unused vars", linux_x64);
251		case.addError(
252		\\pub fn main() void {
253		\\ const x = 1;
254		\\}
255		, &.{":2:11: error: unused local constant"});
256		}
257		{
258		var case = ctx.exe("@TypeOf", linux_x64);
259		case.addCompareOutput(
260		\\pub fn main() void {
261		\\ var x: usize = 0;
262		\\ _ = x;
263		\\ const z = @TypeOf(x, @as(u128, 5));
264		\\ assert(z == u128);
265		\\}
266		\\
267		\\pub fn assert(ok: bool) void {
268		\\ if (!ok) unreachable; // assertion failure
269		\\}
270		,
271		"",
272		);
273		case.addCompareOutput(
274		\\pub fn main() void {
275		\\ const z = @TypeOf(true);
276		\\ assert(z == bool);
277		\\}
278		\\
279		\\pub fn assert(ok: bool) void {
280		\\ if (!ok) unreachable; // assertion failure
281		\\}
282		,
283		"",
284		);
285		case.addError(
286		\\pub fn main() void {
287		\\ _ = @TypeOf(true, 1);
288		\\}
289		, &[_][]const u8{":2:9: error: incompatible types: 'bool' and 'comptime_int'"});
290		}
291
292		{
293		var case = ctx.exe("multiplying numbers at runtime and comptime", linux_x64);
294		case.addCompareOutput(
295		\\pub export fn _start() noreturn {
296		\\ mul(3, 4);
297		\\
298		\\ exit();
299		\\}
300		\\
301		\\fn mul(a: u32, b: u32) void {
302		\\ if (a * b != 12) unreachable;
303		\\}
304		\\
305		\\fn exit() noreturn {
306		\\ asm volatile ("syscall"
307		\\ :
308		\\ : [number] "{rax}" (231),
309		\\ [arg1] "{rdi}" (0)
310		\\ : "rcx", "r11", "memory"
311		\\ );
312		\\ unreachable;
313		\\}
314		,
315		"",
316		);
317		// comptime function call
318		case.addCompareOutput(
319		\\pub fn _start() noreturn {
320		\\ exit();
321		\\}
322		\\
323		\\fn mul(a: u32, b: u32) u32 {
324		\\ return a * b;
325		\\}
326		\\
327		\\const x = mul(3, 4);
328		\\
329		\\fn exit() noreturn {
330		\\ asm volatile ("syscall"
331		\\ :
332		\\ : [number] "{rax}" (231),
333		\\ [arg1] "{rdi}" (x - 12)
334		\\ : "rcx", "r11", "memory"
335		\\ );
336		\\ unreachable;
337		\\}
338		,
339		"",
340		);
341		// Inline function call
342		case.addCompareOutput(
343		\\pub export fn _start() noreturn {
344		\\ var x: usize = 5;
345		\\ const y = mul(2, 3, x);
346		\\ exit(y - 30);
347		\\}
348		\\
349		\\fn mul(a: usize, b: usize, c: usize) callconv(.Inline) usize {
350		\\ return a * b * c;
351		\\}
352		\\
353		\\fn exit(code: usize) noreturn {
354		\\ asm volatile ("syscall"
355		\\ :
356		\\ : [number] "{rax}" (231),
357		\\ [arg1] "{rdi}" (code)
358		\\ : "rcx", "r11", "memory"
359		\\ );
360		\\ unreachable;
361		\\}
362		,
363		"",
364		);
365		}
366
367		{
368		var case = ctx.exe("assert function", linux_x64);
369		case.addCompareOutput(
370		\\pub fn main() void {
371		\\ add(3, 4);
372		\\}
373		\\
374		\\fn add(a: u32, b: u32) void {
375		\\ assert(a + b == 7);
376		\\}
377		\\
378		\\pub fn assert(ok: bool) void {
379		\\ if (!ok) unreachable; // assertion failure
380		\\}
381		\\
382		\\fn exit() noreturn {
383		\\ asm volatile ("syscall"
384		\\ :
385		\\ : [number] "{rax}" (231),
386		\\ [arg1] "{rdi}" (0)
387		\\ : "rcx", "r11", "memory"
388		\\ );
389		\\ unreachable;
390		\\}
391		,
392		"",
393		);
394
395		// Tests copying a register. For the `c = a + b`, it has to
396		// preserve both a and b, because they are both used later.
397		case.addCompareOutput(
398		\\pub fn main() void {
399		\\ add(3, 4);
400		\\}
401		\\
402		\\fn add(a: u32, b: u32) void {
403		\\ const c = a + b; // 7
404		\\ const d = a + c; // 10
405		\\ const e = d + b; // 14
406		\\ assert(e == 14);
407		\\}
408		\\
409		\\pub fn assert(ok: bool) void {
410		\\ if (!ok) unreachable; // assertion failure
411		\\}
412		,
413		"",
414		);
415
416		// More stress on the liveness detection.
417		case.addCompareOutput(
418		\\pub fn main() void {
419		\\ add(3, 4);
420		\\}
421		\\
422		\\fn add(a: u32, b: u32) void {
423		\\ const c = a + b; // 7
424		\\ const d = a + c; // 10
425		\\ const e = d + b; // 14
426		\\ const f = d + e; // 24
427		\\ const g = e + f; // 38
428		\\ const h = f + g; // 62
429		\\ const i = g + h; // 100
430		\\ assert(i == 100);
431		\\}
432		\\
433		\\pub fn assert(ok: bool) void {
434		\\ if (!ok) unreachable; // assertion failure
435		\\}
436		,
437		"",
438		);
439
440		// Requires a second move. The register allocator should figure out to re-use rax.
441		case.addCompareOutput(
442		\\pub fn main() void {
443		\\ add(3, 4);
444		\\}
445		\\
446		\\fn add(a: u32, b: u32) void {
447		\\ const c = a + b; // 7
448		\\ const d = a + c; // 10
449		\\ const e = d + b; // 14
450		\\ const f = d + e; // 24
451		\\ const g = e + f; // 38
452		\\ const h = f + g; // 62
453		\\ const i = g + h; // 100
454		\\ const j = i + d; // 110
455		\\ assert(j == 110);
456		\\}
457		\\
458		\\pub fn assert(ok: bool) void {
459		\\ if (!ok) unreachable; // assertion failure
460		\\}
461		,
462		"",
463		);
464
465		// Now we test integer return values.
466		case.addCompareOutput(
467		\\pub fn main() void {
468		\\ assert(add(3, 4) == 7);
469		\\ assert(add(20, 10) == 30);
470		\\}
471		\\
472		\\fn add(a: u32, b: u32) u32 {
473		\\ return a + b;
474		\\}
475		\\
476		\\pub fn assert(ok: bool) void {
477		\\ if (!ok) unreachable; // assertion failure
478		\\}
479		,
480		"",
481		);
482
483		// Local mutable variables.
484		case.addCompareOutput(
485		\\pub fn main() void {
486		\\ assert(add(3, 4) == 7);
487		\\ assert(add(20, 10) == 30);
488		\\}
489		\\
490		\\fn add(a: u32, b: u32) u32 {
491		\\ var x: u32 = undefined;
492		\\ x = 0;
493		\\ x += a;
494		\\ x += b;
495		\\ return x;
496		\\}
497		\\
498		\\pub fn assert(ok: bool) void {
499		\\ if (!ok) unreachable; // assertion failure
500		\\}
501		,
502		"",
503		);
504
505		// Optionals
506		case.addCompareOutput(
507		\\pub fn main() void {
508		\\ const a: u32 = 2;
509		\\ const b: ?u32 = a;
510		\\ const c = b.?;
511		\\ if (c != 2) unreachable;
512		\\}
513		,
514		"",
515		);
516
517		// While loops
518		case.addCompareOutput(
519		\\pub fn main() void {
520		\\ var i: u32 = 0;
521		\\ while (i < 4) : (i += 1) print();
522		\\ assert(i == 4);
523		\\}
524		\\
525		\\fn print() void {
526		\\ asm volatile ("syscall"
527		\\ :
528		\\ : [number] "{rax}" (1),
529		\\ [arg1] "{rdi}" (1),
530		\\ [arg2] "{rsi}" (@ptrToInt("hello\n")),
531		\\ [arg3] "{rdx}" (6)
532		\\ : "rcx", "r11", "memory"
533		\\ );
534		\\ return;
535		\\}
536		\\
537		\\pub fn assert(ok: bool) void {
538		\\ if (!ok) unreachable; // assertion failure
539		\\}
540		,
541		"hello\nhello\nhello\nhello\n",
542		);
543
544		// inline while requires the condition to be comptime known.
545		case.addError(
546		\\pub fn main() void {
547		\\ var i: u32 = 0;
548		\\ inline while (i < 4) : (i += 1) print();
549		\\ assert(i == 4);
550		\\}
551		\\
552		\\fn print() void {
553		\\ asm volatile ("syscall"
554		\\ :
555		\\ : [number] "{rax}" (1),
556		\\ [arg1] "{rdi}" (1),
557		\\ [arg2] "{rsi}" (@ptrToInt("hello\n")),
558		\\ [arg3] "{rdx}" (6)
559		\\ : "rcx", "r11", "memory"
560		\\ );
561		\\ return;
562		\\}
563		\\
564		\\pub fn assert(ok: bool) void {
565		\\ if (!ok) unreachable; // assertion failure
566		\\}
567		, &[_][]const u8{":3:21: error: unable to resolve comptime value"});
568
569		// Labeled blocks (no conditional branch)
570		case.addCompareOutput(
571		\\pub fn main() void {
572		\\ assert(add(3, 4) == 20);
573		\\}
574		\\
575		\\fn add(a: u32, b: u32) u32 {
576		\\ const x: u32 = blk: {
577		\\ const c = a + b; // 7
578		\\ const d = a + c; // 10
579		\\ const e = d + b; // 14
580		\\ break :blk e;
581		\\ };
582		\\ const y = x + a; // 17
583		\\ const z = y + a; // 20
584		\\ return z;
585		\\}
586		\\
587		\\pub fn assert(ok: bool) void {
588		\\ if (!ok) unreachable; // assertion failure
589		\\}
590		,
591		"",
592		);
593
594		// This catches a possible bug in the logic for re-using dying operands.
595		case.addCompareOutput(
596		\\pub fn main() void {
597		\\ assert(add(3, 4) == 116);
598		\\}
599		\\
600		\\fn add(a: u32, b: u32) u32 {
601		\\ const x: u32 = blk: {
602		\\ const c = a + b; // 7
603		\\ const d = a + c; // 10
604		\\ const e = d + b; // 14
605		\\ const f = d + e; // 24
606		\\ const g = e + f; // 38
607		\\ const h = f + g; // 62
608		\\ const i = g + h; // 100
609		\\ const j = i + d; // 110
610		\\ break :blk j;
611		\\ };
612		\\ const y = x + a; // 113
613		\\ const z = y + a; // 116
614		\\ return z;
615		\\}
616		\\
617		\\pub fn assert(ok: bool) void {
618		\\ if (!ok) unreachable; // assertion failure
619		\\}
620		,
621		"",
622		);
623
624		// Spilling registers to the stack.
625		case.addCompareOutput(
626		\\pub fn main() void {
627		\\ assert(add(3, 4) == 1221);
628		\\ assert(mul(3, 4) == 21609);
629		\\}
630		\\
631		\\fn add(a: u32, b: u32) u32 {
632		\\ const x: u32 = blk: {
633		\\ const c = a + b; // 7
634		\\ const d = a + c; // 10
635		\\ const e = d + b; // 14
636		\\ const f = d + e; // 24
637		\\ const g = e + f; // 38
638		\\ const h = f + g; // 62
639		\\ const i = g + h; // 100
640		\\ const j = i + d; // 110
641		\\ const k = i + j; // 210
642		\\ const l = j + k; // 320
643		\\ const m = l + c; // 327
644		\\ const n = m + d; // 337
645		\\ const o = n + e; // 351
646		\\ const p = o + f; // 375
647		\\ const q = p + g; // 413
648		\\ const r = q + h; // 475
649		\\ const s = r + i; // 575
650		\\ const t = s + j; // 685
651		\\ const u = t + k; // 895
652		\\ const v = u + l; // 1215
653		\\ break :blk v;
654		\\ };
655		\\ const y = x + a; // 1218
656		\\ const z = y + a; // 1221
657		\\ return z;
658		\\}
659		\\
660		\\fn mul(a: u32, b: u32) u32 {
661		\\ const x: u32 = blk: {
662		\\ const c = a * a * a * a; // 81
663		\\ const d = a * a * a * b; // 108
664		\\ const e = a * a * b * a; // 108
665		\\ const f = a * a * b * b; // 144
666		\\ const g = a * b * a * a; // 108
667		\\ const h = a * b * a * b; // 144
668		\\ const i = a * b * b * a; // 144
669		\\ const j = a * b * b * b; // 192
670		\\ const k = b * a * a * a; // 108
671		\\ const l = b * a * a * b; // 144
672		\\ const m = b * a * b * a; // 144
673		\\ const n = b * a * b * b; // 192
674		\\ const o = b * b * a * a; // 144
675		\\ const p = b * b * a * b; // 192
676		\\ const q = b * b * b * a; // 192
677		\\ const r = b * b * b * b; // 256
678		\\ const s = c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r; // 2401
679		\\ break :blk s;
680		\\ };
681		\\ const y = x * a; // 7203
682		\\ const z = y * a; // 21609
683		\\ return z;
684		\\}
685		\\
686		\\pub fn assert(ok: bool) void {
687		\\ if (!ok) unreachable; // assertion failure
688		\\}
689		,
690		"",
691		);
692
693		// Reusing the registers of dead operands playing nicely with conditional branching.
694		case.addCompareOutput(
695		\\pub fn main() void {
696		\\ assert(add(3, 4) == 791);
697		\\ assert(add(4, 3) == 79);
698		\\}
699		\\
700		\\fn add(a: u32, b: u32) u32 {
701		\\ const x: u32 = if (a < b) blk: {
702		\\ const c = a + b; // 7
703		\\ const d = a + c; // 10
704		\\ const e = d + b; // 14
705		\\ const f = d + e; // 24
706		\\ const g = e + f; // 38
707		\\ const h = f + g; // 62
708		\\ const i = g + h; // 100
709		\\ const j = i + d; // 110
710		\\ const k = i + j; // 210
711		\\ const l = k + c; // 217
712		\\ const m = l + d; // 227
713		\\ const n = m + e; // 241
714		\\ const o = n + f; // 265
715		\\ const p = o + g; // 303
716		\\ const q = p + h; // 365
717		\\ const r = q + i; // 465
718		\\ const s = r + j; // 575
719		\\ const t = s + k; // 785
720		\\ break :blk t;
721		\\ } else blk: {
722		\\ const t = b + b + a; // 10
723		\\ const c = a + t; // 14
724		\\ const d = c + t; // 24
725		\\ const e = d + t; // 34
726		\\ const f = e + t; // 44
727		\\ const g = f + t; // 54
728		\\ const h = c + g; // 68
729		\\ break :blk h + b; // 71
730		\\ };
731		\\ const y = x + a; // 788, 75
732		\\ const z = y + a; // 791, 79
733		\\ return z;
734		\\}
735		\\
736		\\pub fn assert(ok: bool) void {
737		\\ if (!ok) unreachable; // assertion failure
738		\\}
739		,
740		"",
741		);
742
743		// Character literals and multiline strings.
744		case.addCompareOutput(
745		\\pub fn main() void {
746		\\ const ignore =
747		\\ \\ cool thx
748		\\ \\
749		\\ ;
750		\\ _ = ignore;
751		\\ add('ぁ', '\x03');
752		\\}
753		\\
754		\\fn add(a: u32, b: u32) void {
755		\\ assert(a + b == 12356);
756		\\}
757		\\
758		\\pub fn assert(ok: bool) void {
759		\\ if (!ok) unreachable; // assertion failure
760		\\}
761		,
762		"",
763		);
764
765		// Global const.
766		case.addCompareOutput(
767		\\pub fn main() void {
768		\\ add(aa, bb);
769		\\}
770		\\
771		\\const aa = 'ぁ';
772		\\const bb = '\x03';
773		\\
774		\\fn add(a: u32, b: u32) void {
775		\\ assert(a + b == 12356);
776		\\}
777		\\
778		\\pub fn assert(ok: bool) void {
779		\\ if (!ok) unreachable; // assertion failure
780		\\}
781		,
782		"",
783		);
784
785		// Array access.
786		case.addCompareOutput(
787		\\pub fn main() void {
788		\\ assert("hello"[0] == 'h');
789		\\}
790		\\
791		\\pub fn assert(ok: bool) void {
792		\\ if (!ok) unreachable; // assertion failure
793		\\}
794		,
795		"",
796		);
797
798		// Array access to a global array.
799		case.addCompareOutput(
800		\\const hello = "hello".*;
801		\\pub fn main() void {
802		\\ assert(hello[1] == 'e');
803		\\}
804		\\
805		\\pub fn assert(ok: bool) void {
806		\\ if (!ok) unreachable; // assertion failure
807		\\}
808		,
809		"",
810		);
811
812		// 64bit set stack
813		case.addCompareOutput(
814		\\pub fn main() void {
815		\\ var i: u64 = 0xFFEEDDCCBBAA9988;
816		\\ assert(i == 0xFFEEDDCCBBAA9988);
817		\\}
818		\\
819		\\pub fn assert(ok: bool) void {
820		\\ if (!ok) unreachable; // assertion failure
821		\\}
822		,
823		"",
824		);
825
826		// Basic for loop
827		case.addCompareOutput(
828		\\pub fn main() void {
829		\\ for ("hello") \|_\| print();
830		\\}
831		\\
832		\\fn print() void {
833		\\ asm volatile ("syscall"
834		\\ :
835		\\ : [number] "{rax}" (1),
836		\\ [arg1] "{rdi}" (1),
837		\\ [arg2] "{rsi}" (@ptrToInt("hello\n")),
838		\\ [arg3] "{rdx}" (6)
839		\\ : "rcx", "r11", "memory"
840		\\ );
841		\\ return;
842		\\}
843		,
844		"hello\nhello\nhello\nhello\nhello\n",
845		);
846		}
847
848		{
849		var case = ctx.exe("basic import", linux_x64);
850		case.addCompareOutput(
851		\\pub fn main() void {
852		\\ @import("print.zig").print();
853		\\}
854		,
855		"Hello, World!\n",
856		);
857		try case.files.append(.{
858		.src =
859		\\pub fn print() void {
860		\\ asm volatile ("syscall"
861		\\ :
862		\\ : [number] "{rax}" (@as(usize, 1)),
863		\\ [arg1] "{rdi}" (@as(usize, 1)),
864		\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
865		\\ [arg3] "{rdx}" (@as(usize, 14))
866		\\ : "rcx", "r11", "memory"
867		\\ );
868		\\ return;
869		\\}
870		,
871		.path = "print.zig",
872		});
873		}
874		{
875		var case = ctx.exe("redundant comptime", linux_x64);
876		case.addError(
877		\\pub fn main() void {
878		\\ var a: comptime u32 = 0;
879		\\}
880		,
881		&.{":2:12: error: redundant comptime keyword in already comptime scope"},
882		);
883		case.addError(
884		\\pub fn main() void {
885		\\ comptime {
886		\\ var a: u32 = comptime 0;
887		\\ }
888		\\}
889		,
890		&.{":3:22: error: redundant comptime keyword in already comptime scope"},
891		);
892		}
893		{
894		var case = ctx.exe("try in comptime in struct in test", linux_x64);
895		case.addError(
896		\\test "@unionInit on union w/ tag but no fields" {
897		\\ const S = struct {
898		\\ comptime {
899		\\ try expect(false);
900		\\ }
901		\\ };
902		\\ _ = S;
903		\\}
904		,
905		&.{":4:13: error: invalid 'try' outside function scope"},
906		);
907		}
908		{
909		var case = ctx.exe("import private", linux_x64);
910		case.addError(
911		\\pub fn main() void {
912		\\ @import("print.zig").print();
913		\\}
914		,
915		&.{
916		":2:25: error: 'print' is not marked 'pub'",
917		"print.zig:2:1: note: declared here",
918		},
919		);
920		try case.files.append(.{
921		.src =
922		\\// dummy comment to make print be on line 2
923		\\fn print() void {
924		\\ asm volatile ("syscall"
925		\\ :
926		\\ : [number] "{rax}" (@as(usize, 1)),
927		\\ [arg1] "{rdi}" (@as(usize, 1)),
928		\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
929		\\ [arg3] "{rdx}" (@as(usize, 14))
930		\\ : "rcx", "r11", "memory"
931		\\ );
932		\\ return;
933		\\}
934		,
935		.path = "print.zig",
936		});
937		}
938
939		ctx.compileError("function redeclaration", linux_x64,
940		\\// dummy comment
941		\\fn entry() void {}
942		\\fn entry() void {}
943		\\
944		\\fn foo() void {
945		\\ var foo = 1234;
946		\\}
947		, &[_][]const u8{
948		":3:1: error: redeclaration of 'entry'",
949		":2:1: note: other declaration here",
950		":6:9: error: local shadows declaration of 'foo'",
951		":5:1: note: declared here",
952		});
953
954		ctx.compileError("returns in try", linux_x64,
955		\\pub fn main() !void {
956		\\ try a();
957		\\ try b();
958		\\}
959		\\
960		\\pub fn a() !void {
961		\\ defer try b();
962		\\}
963		\\pub fn b() !void {
964		\\ defer return a();
965		\\}
966		, &[_][]const u8{
967		":7:8: error: try is not allowed inside defer expression",
968		":10:8: error: cannot return from defer expression",
969		});
970
971		ctx.compileError("ambiguous references", linux_x64,
972		\\const T = struct {
973		\\ const T = struct {
974		\\ fn f() void {
975		\\ _ = T;
976		\\ }
977		\\ };
978		\\};
979		, &.{
980		":4:17: error: ambiguous reference",
981		":1:1: note: declared here",
982		":2:5: note: also declared here",
983		});
984
985		ctx.compileError("inner func accessing outer var", linux_x64,
986		\\pub fn f() void {
987		\\ var bar: bool = true;
988		\\ const S = struct {
989		\\ fn baz() bool {
990		\\ return bar;
991		\\ }
992		\\ };
993		\\ _ = S;
994		\\}
995		, &.{
996		":5:20: error: 'bar' not accessible from inner function",
997		":2:9: note: declared here",
998		});
999
1000		ctx.compileError("global variable redeclaration", linux_x64,
1001		\\// dummy comment
1002		\\var foo = false;
1003		\\var foo = true;
1004		, &[_][]const u8{
1005		":3:1: error: redeclaration of 'foo'",
1006		":2:1: note: other declaration here",
1007		});
1008
1009		ctx.compileError("compileError", linux_x64,
1010		\\export fn foo() void {
1011		\\ @compileError("this is an error");
1012		\\}
1013		, &[_][]const u8{":2:3: error: this is an error"});
1014
1015		{
1016		var case = ctx.exe("intToPtr", linux_x64);
1017		case.addError(
1018		\\pub fn main() void {
1019		\\ _ = @intToPtr(*u8, 0);
1020		\\}
1021		, &[_][]const u8{
1022		":2:24: error: pointer type '*u8' does not allow address zero",
1023		});
1024		case.addError(
1025		\\pub fn main() void {
1026		\\ _ = @intToPtr(*u32, 2);
1027		\\}
1028		, &[_][]const u8{
1029		":2:25: error: pointer type '*u32' requires aligned address",
1030		});
1031		}
1032
1033		{
1034		var case = ctx.obj("variable shadowing", linux_x64);
1035		case.addError(
1036		\\pub fn main() void {
1037		\\ var i: u32 = 10;
1038		\\ var i: u32 = 10;
1039		\\}
1040		, &[_][]const u8{
1041		":3:9: error: redeclaration of 'i'",
1042		":2:9: note: previously declared here",
1043		});
1044		case.addError(
1045		\\var testing: i64 = 10;
1046		\\pub fn main() void {
1047		\\ var testing: i64 = 20;
1048		\\}
1049		, &[_][]const u8{
1050		":3:9: error: local shadows declaration of 'testing'",
1051		":1:1: note: declared here",
1052		});
1053		case.addError(
1054		\\fn a() type {
1055		\\ return struct {
1056		\\ pub fn b() void {
1057		\\ const c = 6;
1058		\\ const c = 69;
1059		\\ }
1060		\\ };
1061		\\}
1062		, &[_][]const u8{
1063		":5:19: error: redeclaration of 'c'",
1064		":4:19: note: previously declared here",
1065		});
1066		}
1067
1068		{
1069		// TODO make the test harness support checking the compile log output too
1070		var case = ctx.obj("@compileLog", linux_x64);
1071		// The other compile error prevents emission of a "found compile log" statement.
1072		case.addError(
1073		\\export fn _start() noreturn {
1074		\\ const b = true;
1075		\\ var f: u32 = 1;
1076		\\ @compileLog(b, 20, f, x);
1077		\\ @compileLog(1000);
1078		\\ var bruh: usize = true;
1079		\\ _ = bruh;
1080		\\ unreachable;
1081		\\}
1082		\\export fn other() void {
1083		\\ @compileLog(1234);
1084		\\}
1085		\\fn x() void {}
1086		, &[_][]const u8{
1087		":6:23: error: expected usize, found bool",
1088		});
1089
1090		// Now only compile log statements remain. One per Decl.
1091		case.addError(
1092		\\export fn _start() noreturn {
1093		\\ const b = true;
1094		\\ var f: u32 = 1;
1095		\\ @compileLog(b, 20, f, x);
1096		\\ @compileLog(1000);
1097		\\ unreachable;
1098		\\}
1099		\\export fn other() void {
1100		\\ @compileLog(1234);
1101		\\}
1102		\\fn x() void {}
1103		, &[_][]const u8{
1104		":9:5: error: found compile log statement",
1105		":4:5: note: also here",
1106		});
1107		}
1108
1109		{
1110		var case = ctx.obj("extern variable has no type", linux_x64);
1111		case.addError(
1112		\\comptime {
1113		\\ _ = foo;
1114		\\}
1115		\\extern var foo: i32;
1116		, &[_][]const u8{":2:9: error: unable to resolve comptime value"});
1117		case.addError(
1118		\\export fn entry() void {
1119		\\ _ = foo;
1120		\\}
1121		\\extern var foo;
1122		, &[_][]const u8{":4:8: error: unable to infer variable type"});
1123		}
1124
1125		{
1126		var case = ctx.exe("break/continue", linux_x64);
1127
1128		// Break out of loop
1129		case.addCompareOutput(
1130		\\pub fn main() void {
1131		\\ while (true) {
1132		\\ break;
1133		\\ }
1134		\\}
1135		,
1136		"",
1137		);
1138		case.addCompareOutput(
1139		\\pub fn main() void {
1140		\\ foo: while (true) {
1141		\\ break :foo;
1142		\\ }
1143		\\}
1144		,
1145		"",
1146		);
1147
1148		// Continue in loop
1149		case.addCompareOutput(
1150		\\pub export fn _start() noreturn {
1151		\\ var i: u64 = 0;
1152		\\ while (true) : (i+=1) {
1153		\\ if (i == 4) exit();
1154		\\ continue;
1155		\\ }
1156		\\}
1157		\\
1158		\\fn exit() noreturn {
1159		\\ asm volatile ("syscall"
1160		\\ :
1161		\\ : [number] "{rax}" (231),
1162		\\ [arg1] "{rdi}" (0)
1163		\\ : "rcx", "r11", "memory"
1164		\\ );
1165		\\ unreachable;
1166		\\}
1167		,
1168		"",
1169		);
1170		case.addCompareOutput(
1171		\\pub export fn _start() noreturn {
1172		\\ var i: u64 = 0;
1173		\\ foo: while (true) : (i+=1) {
1174		\\ if (i == 4) exit();
1175		\\ continue :foo;
1176		\\ }
1177		\\}
1178		\\
1179		\\fn exit() noreturn {
1180		\\ asm volatile ("syscall"
1181		\\ :
1182		\\ : [number] "{rax}" (231),
1183		\\ [arg1] "{rdi}" (0)
1184		\\ : "rcx", "r11", "memory"
1185		\\ );
1186		\\ unreachable;
1187		\\}
1188		,
1189		"",
1190		);
1191		}
1192
1193		{
1194		var case = ctx.exe("unused labels", linux_x64);
1195		case.addError(
1196		\\comptime {
1197		\\ foo: {}
1198		\\}
1199		, &[_][]const u8{":2:5: error: unused block label"});
1200		case.addError(
1201		\\comptime {
1202		\\ foo: while (true) {}
1203		\\}
1204		, &[_][]const u8{":2:5: error: unused while loop label"});
1205		case.addError(
1206		\\comptime {
1207		\\ foo: for ("foo") \|_\| {}
1208		\\}
1209		, &[_][]const u8{":2:5: error: unused for loop label"});
1210		case.addError(
1211		\\comptime {
1212		\\ blk: {blk: {}}
1213		\\}
1214		, &[_][]const u8{
1215		":2:11: error: redefinition of label 'blk'",
1216		":2:5: note: previous definition is here",
1217		});
1218		}
1219
1220		{
1221		var case = ctx.exe("bad inferred variable type", linux_x64);
1222		case.addError(
1223		\\pub fn main() void {
1224		\\ var x = null;
1225		\\ _ = x;
1226		\\}
1227		, &[_][]const u8{
1228		":2:9: error: variable of type '@Type(.Null)' must be const or comptime",
1229		});
1230		}
1231
1232		{
1233		var case = ctx.exe("compile error in inline fn call fixed", linux_x64);
1234		case.addError(
1235		\\pub export fn _start() noreturn {
1236		\\ var x: usize = 3;
1237		\\ const y = add(10, 2, x);
1238		\\ exit(y - 6);
1239		\\}
1240		\\
1241		\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
1242		\\ if (a == 10) @compileError("bad");
1243		\\ return a + b + c;
1244		\\}
1245		\\
1246		\\fn exit(code: usize) noreturn {
1247		\\ asm volatile ("syscall"
1248		\\ :
1249		\\ : [number] "{rax}" (231),
1250		\\ [arg1] "{rdi}" (code)
1251		\\ : "rcx", "r11", "memory"
1252		\\ );
1253		\\ unreachable;
1254		\\}
1255		, &[_][]const u8{":8:18: error: bad"});
1256
1257		case.addCompareOutput(
1258		\\pub export fn _start() noreturn {
1259		\\ var x: usize = 3;
1260		\\ const y = add(1, 2, x);
1261		\\ exit(y - 6);
1262		\\}
1263		\\
1264		\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
1265		\\ if (a == 10) @compileError("bad");
1266		\\ return a + b + c;
1267		\\}
1268		\\
1269		\\fn exit(code: usize) noreturn {
1270		\\ asm volatile ("syscall"
1271		\\ :
1272		\\ : [number] "{rax}" (231),
1273		\\ [arg1] "{rdi}" (code)
1274		\\ : "rcx", "r11", "memory"
1275		\\ );
1276		\\ unreachable;
1277		\\}
1278		,
1279		"",
1280		);
1281		}
1282		{
1283		var case = ctx.exe("recursive inline function", linux_x64);
1284		case.addCompareOutput(
1285		\\pub export fn _start() noreturn {
1286		\\ const y = fibonacci(7);
1287		\\ exit(y - 21);
1288		\\}
1289		\\
1290		\\fn fibonacci(n: usize) callconv(.Inline) usize {
1291		\\ if (n <= 2) return n;
1292		\\ return fibonacci(n - 2) + fibonacci(n - 1);
1293		\\}
1294		\\
1295		\\fn exit(code: usize) noreturn {
1296		\\ asm volatile ("syscall"
1297		\\ :
1298		\\ : [number] "{rax}" (231),
1299		\\ [arg1] "{rdi}" (code)
1300		\\ : "rcx", "r11", "memory"
1301		\\ );
1302		\\ unreachable;
1303		\\}
1304		,
1305		"",
1306		);
1307		// This additionally tests that the compile error reports the correct source location.
1308		// Without storing source locations relative to the owner decl, the compile error
1309		// here would be off by 2 bytes (from the "7" -> "999").
1310		case.addError(
1311		\\pub export fn _start() noreturn {
1312		\\ const y = fibonacci(999);
1313		\\ exit(y - 21);
1314		\\}
1315		\\
1316		\\fn fibonacci(n: usize) callconv(.Inline) usize {
1317		\\ if (n <= 2) return n;
1318		\\ return fibonacci(n - 2) + fibonacci(n - 1);
1319		\\}
1320		\\
1321		\\fn exit(code: usize) noreturn {
1322		\\ asm volatile ("syscall"
1323		\\ :
1324		\\ : [number] "{rax}" (231),
1325		\\ [arg1] "{rdi}" (code)
1326		\\ : "rcx", "r11", "memory"
1327		\\ );
1328		\\ unreachable;
1329		\\}
1330		, &[_][]const u8{":8:21: error: evaluation exceeded 1000 backwards branches"});
1331		}
1332		{
1333		var case = ctx.exe("orelse at comptime", linux_x64);
1334		case.addCompareOutput(
1335		\\pub fn main() void {
1336		\\ const i: ?u64 = 0;
1337		\\ const result = i orelse 5;
1338		\\ assert(result == 0);
1339		\\}
1340		\\fn assert(b: bool) void {
1341		\\ if (!b) unreachable;
1342		\\}
1343		,
1344		"",
1345		);
1346		case.addCompareOutput(
1347		\\pub fn main() void {
1348		\\ const i: ?u64 = null;
1349		\\ const result = i orelse 5;
1350		\\ assert(result == 5);
1351		\\}
1352		\\fn assert(b: bool) void {
1353		\\ if (!b) unreachable;
1354		\\}
1355		,
1356		"",
1357		);
1358		}
1359
1360		{
1361		var case = ctx.exe("only 1 function and it gets updated", linux_x64);
1362		case.addCompareOutput(
1363		\\pub export fn _start() noreturn {
1364		\\ asm volatile ("syscall"
1365		\\ :
1366		\\ : [number] "{rax}" (60), // exit
1367		\\ [arg1] "{rdi}" (0)
1368		\\ : "rcx", "r11", "memory"
1369		\\ );
1370		\\ unreachable;
1371		\\}
1372		,
1373		"",
1374		);
1375		case.addCompareOutput(
1376		\\pub export fn _start() noreturn {
1377		\\ asm volatile ("syscall"
1378		\\ :
1379		\\ : [number] "{rax}" (231), // exit_group
1380		\\ [arg1] "{rdi}" (0)
1381		\\ : "rcx", "r11", "memory"
1382		\\ );
1383		\\ unreachable;
1384		\\}
1385		,
1386		"",
1387		);
1388		}
1389		{
1390		var case = ctx.exe("passing u0 to function", linux_x64);
1391		case.addCompareOutput(
1392		\\pub fn main() void {
1393		\\ doNothing(0);
1394		\\}
1395		\\fn doNothing(arg: u0) void {
1396		\\ _ = arg;
1397		\\}
1398		,
1399		"",
1400		);
1401		}
1402		{
1403		var case = ctx.exe("catch at comptime", linux_x64);
1404		case.addCompareOutput(
1405		\\pub fn main() void {
1406		\\ const i: anyerror!u64 = 0;
1407		\\ const caught = i catch 5;
1408		\\ assert(caught == 0);
1409		\\}
1410		\\fn assert(b: bool) void {
1411		\\ if (!b) unreachable;
1412		\\}
1413		,
1414		"",
1415		);
1416
1417		case.addCompareOutput(
1418		\\pub fn main() void {
1419		\\ const i: anyerror!u64 = error.B;
1420		\\ const caught = i catch 5;
1421		\\ assert(caught == 5);
1422		\\}
1423		\\fn assert(b: bool) void {
1424		\\ if (!b) unreachable;
1425		\\}
1426		,
1427		"",
1428		);
1429
1430		case.addCompareOutput(
1431		\\pub fn main() void {
1432		\\ const a: anyerror!comptime_int = 42;
1433		\\ const b: *const comptime_int = &(a catch unreachable);
1434		\\ assert(b.* == 42);
1435		\\}
1436		\\fn assert(b: bool) void {
1437		\\ if (!b) unreachable; // assertion failure
1438		\\}
1439		, "");
1440
1441		case.addCompareOutput(
1442		\\pub fn main() void {
1443		\\ const a: anyerror!u32 = error.B;
1444		\\ _ = &(a catch \|err\| assert(err == error.B));
1445		\\}
1446		\\fn assert(b: bool) void {
1447		\\ if (!b) unreachable;
1448		\\}
1449		, "");
1450
1451		case.addCompareOutput(
1452		\\pub fn main() void {
1453		\\ const a: anyerror!u32 = error.Bar;
1454		\\ a catch \|err\| assert(err == error.Bar);
1455		\\}
1456		\\fn assert(b: bool) void {
1457		\\ if (!b) unreachable;
1458		\\}
1459		, "");
1460		}
1461		{
1462		var case = ctx.exe("merge error sets", linux_x64);
1463
1464		case.addCompareOutput(
1465		\\pub fn main() void {
1466		\\ const E = error{ A, B, D } \|\| error { A, B, C };
1467		\\ E.A catch {};
1468		\\ E.B catch {};
1469		\\ E.C catch {};
1470		\\ E.D catch {};
1471		\\ const E2 = error { X, Y } \|\| @TypeOf(error.Z);
1472		\\ E2.X catch {};
1473		\\ E2.Y catch {};
1474		\\ E2.Z catch {};
1475		\\ assert(anyerror \|\| error { Z } == anyerror);
1476		\\}
1477		\\fn assert(b: bool) void {
1478		\\ if (!b) unreachable;
1479		\\}
1480		,
1481		"",
1482		);
1483		}
1484		{
1485		var case = ctx.exe("inline assembly", linux_x64);
1486
1487		case.addError(
1488		\\pub fn main() void {
1489		\\ const number = 1234;
1490		\\ const x = asm volatile ("syscall"
1491		\\ : [o] "{rax}" (-> number)
1492		\\ : [number] "{rax}" (231),
1493		\\ [arg1] "{rdi}" (code)
1494		\\ : "rcx", "r11", "memory"
1495		\\ );
1496		\\ _ = x;
1497		\\}
1498		, &[_][]const u8{":4:27: error: expected type, found comptime_int"});
1499		}
1500		{
1501		var case = ctx.exe("comptime var", linux_x64);
1502
1503		case.addError(
1504		\\pub fn main() void {
1505		\\ var a: u32 = 0;
1506		\\ comptime var b: u32 = 0;
1507		\\ if (a == 0) b = 3;
1508		\\}
1509		, &.{
1510		":4:21: error: store to comptime variable depends on runtime condition",
1511		":4:11: note: runtime condition here",
1512		});
1513
1514		case.addError(
1515		\\pub fn main() void {
1516		\\ var a: u32 = 0;
1517		\\ comptime var b: u32 = 0;
1518		\\ switch (a) {
1519		\\ 0 => {},
1520		\\ else => b = 3,
1521		\\ }
1522		\\}
1523		, &.{
1524		":6:21: error: store to comptime variable depends on runtime condition",
1525		":4:13: note: runtime condition here",
1526		});
1527
1528		case.addCompareOutput(
1529		\\pub fn main() void {
1530		\\ comptime var len: u32 = 5;
1531		\\ print(len);
1532		\\ len += 9;
1533		\\ print(len);
1534		\\}
1535		\\
1536		\\fn print(len: usize) void {
1537		\\ asm volatile ("syscall"
1538		\\ :
1539		\\ : [number] "{rax}" (1),
1540		\\ [arg1] "{rdi}" (1),
1541		\\ [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
1542		\\ [arg3] "{rdx}" (len)
1543		\\ : "rcx", "r11", "memory"
1544		\\ );
1545		\\ return;
1546		\\}
1547		, "HelloHello, World!\n");
1548
1549		case.addError(
1550		\\comptime {
1551		\\ var x: i32 = 1;
1552		\\ x += 1;
1553		\\ if (x != 1) unreachable;
1554		\\}
1555		\\pub fn main() void {}
1556		, &.{":4:17: error: unable to resolve comptime value"});
1557
1558		case.addError(
1559		\\pub fn main() void {
1560		\\ comptime var i: u64 = 0;
1561		\\ while (i < 5) : (i += 1) {}
1562		\\}
1563		, &.{
1564		":3:24: error: cannot store to comptime variable in non-inline loop",
1565		":3:5: note: non-inline loop here",
1566		});
1567
1568		case.addCompareOutput(
1569		\\pub fn main() void {
1570		\\ var a: u32 = 0;
1571		\\ if (a == 0) {
1572		\\ comptime var b: u32 = 0;
1573		\\ b = 1;
1574		\\ }
1575		\\}
1576		\\comptime {
1577		\\ var x: i32 = 1;
1578		\\ x += 1;
1579		\\ if (x != 2) unreachable;
1580		\\}
1581		, "");
1582
1583		case.addCompareOutput(
1584		\\pub fn main() void {
1585		\\ comptime var i: u64 = 2;
1586		\\ inline while (i < 6) : (i+=1) {
1587		\\ print(i);
1588		\\ }
1589		\\}
1590		\\fn print(len: usize) void {
1591		\\ asm volatile ("syscall"
1592		\\ :
1593		\\ : [number] "{rax}" (1),
1594		\\ [arg1] "{rdi}" (1),
1595		\\ [arg2] "{rsi}" (@ptrToInt("Hello")),
1596		\\ [arg3] "{rdx}" (len)
1597		\\ : "rcx", "r11", "memory"
1598		\\ );
1599		\\ return;
1600		\\}
1601		, "HeHelHellHello");
1602		}
1603
1604		{
1605		var case = ctx.exe("double ampersand", linux_x64);
1606
1607		case.addError(
1608		\\pub const a = if (true && false) 1 else 2;
1609		, &[_][]const u8{":1:24: error: `&&` is invalid; note that `and` is boolean AND"});
1610
1611		case.addError(
1612		\\pub fn main() void {
1613		\\ const a = true;
1614		\\ const b = false;
1615		\\ _ = a & &b;
1616		\\}
1617		, &[_][]const u8{":4:11: error: incompatible types: 'bool' and '*const bool'"});
1618
1619		case.addCompareOutput(
1620		\\pub fn main() void {
1621		\\ const b: u8 = 1;
1622		\\ _ = &&b;
1623		\\}
1624		, "");
1625		}
1626		}

test/tests.zig-321

...	...	@@ -16,7 +16,6 @@ const LibExeObjStep = build.LibExeObjStep;
16	16	const compare_output = @import("compare_output.zig");
17	17	const standalone = @import("standalone.zig");
18	18	const stack_traces = @import("stack_traces.zig");
19		const compile_errors = @import("compile_errors.zig");
20	19	const assemble_and_link = @import("assemble_and_link.zig");
21	20	const runtime_safety = @import("runtime_safety.zig");
22	21	const translate_c = @import("translate_c.zig");
...	...	@@ -384,21 +383,6 @@ pub fn addRuntimeSafetyTests(b: *build.Builder, test_filter: ?[]const u8, modes:
384	383	return cases.step;
385	384	}
386	385
387		pub fn addCompileErrorTests(b: build.Builder, test_filter: ?[]const u8, modes: []const Mode) build.Step {
388		const cases = b.allocator.create(CompileErrorContext) catch unreachable;
389		cases.* = CompileErrorContext{
390		.b = b,
391		.step = b.step("test-compile-errors", "Run the compile error tests"),
392		.test_index = 0,
393		.test_filter = test_filter,
394		.modes = modes,
395		};
396
397		compile_errors.addCases(cases);
398
399		return cases.step;
400		}
401
402	386	pub fn addStandaloneTests(b: build.Builder, test_filter: ?[]const u8, modes: []const Mode, skip_non_native: bool, target: std.zig.CrossTarget) build.Step {
403	387	const cases = b.allocator.create(StandaloneContext) catch unreachable;
404	388	cases.* = StandaloneContext{
...	...	@@ -840,304 +824,6 @@ pub const StackTracesContext = struct {
840	824	};
841	825	};
842	826
843		pub const CompileErrorContext = struct {
844		b: *build.Builder,
845		step: *build.Step,
846		test_index: usize,
847		test_filter: ?[]const u8,
848		modes: []const Mode,
849
850		const TestCase = struct {
851		name: []const u8,
852		sources: ArrayList(SourceFile),
853		expected_errors: ArrayList([]const u8),
854		expect_exact: bool,
855		link_libc: bool,
856		is_exe: bool,
857		is_test: bool,
858		target: CrossTarget = CrossTarget{},
859
860		const SourceFile = struct {
861		filename: []const u8,
862		source: []const u8,
863		};
864
865		pub fn addSourceFile(self: *TestCase, filename: []const u8, source: []const u8) void {
866		self.sources.append(SourceFile{
867		.filename = filename,
868		.source = source,
869		}) catch unreachable;
870		}
871
872		pub fn addExpectedError(self: *TestCase, text: []const u8) void {
873		self.expected_errors.append(text) catch unreachable;
874		}
875		};
876
877		const CompileCmpOutputStep = struct {
878		pub const base_id = .custom;
879
880		step: build.Step,
881		context: *CompileErrorContext,
882		name: []const u8,
883		test_index: usize,
884		case: *const TestCase,
885		build_mode: Mode,
886		write_src: *build.WriteFileStep,
887
888		const ErrLineIter = struct {
889		lines: mem.SplitIterator,
890
891		const source_file = "tmp.zig";
892
893		fn init(input: []const u8) ErrLineIter {
894		return ErrLineIter{ .lines = mem.split(input, "\n") };
895		}
896
897		fn next(self: *ErrLineIter) ?[]const u8 {
898		while (self.lines.next()) \|line\| {
899		if (mem.indexOf(u8, line, source_file) != null)
900		return line;
901		}
902		return null;
903		}
904		};
905
906		pub fn create(
907		context: *CompileErrorContext,
908		name: []const u8,
909		case: *const TestCase,
910		build_mode: Mode,
911		write_src: *build.WriteFileStep,
912		) *CompileCmpOutputStep {
913		const allocator = context.b.allocator;
914		const ptr = allocator.create(CompileCmpOutputStep) catch unreachable;
915		ptr.* = CompileCmpOutputStep{
916		.step = build.Step.init(.custom, "CompileCmpOutput", allocator, make),
917		.context = context,
918		.name = name,
919		.test_index = context.test_index,
920		.case = case,
921		.build_mode = build_mode,
922		.write_src = write_src,
923		};
924
925		context.test_index += 1;
926		return ptr;
927		}
928
929		fn make(step: *build.Step) !void {
930		const self = @fieldParentPtr(CompileCmpOutputStep, "step", step);
931		const b = self.context.b;
932
933		var zig_args = ArrayList([]const u8).init(b.allocator);
934		zig_args.append(b.zig_exe) catch unreachable;
935
936		if (self.case.is_exe) {
937		try zig_args.append("build-exe");
938		} else if (self.case.is_test) {
939		try zig_args.append("test");
940		} else {
941		try zig_args.append("build-obj");
942		}
943		const root_src_basename = self.case.sources.items[0].filename;
944		try zig_args.append(self.write_src.getFileSource(root_src_basename).?.getPath(b));
945
946		zig_args.append("--name") catch unreachable;
947		zig_args.append("test") catch unreachable;
948
949		if (!self.case.target.isNative()) {
950		try zig_args.append("-target");
951		try zig_args.append(try self.case.target.zigTriple(b.allocator));
952		}
953
954		zig_args.append("-O") catch unreachable;
955		zig_args.append(@tagName(self.build_mode)) catch unreachable;
956
957		warn("Test {d}/{d} {s}...", .{ self.test_index + 1, self.context.test_index, self.name });
958
959		if (b.verbose) {
960		printInvocation(zig_args.items);
961		}
962
963		const child = std.ChildProcess.init(zig_args.items, b.allocator) catch unreachable;
964		defer child.deinit();
965
966		child.env_map = b.env_map;
967		child.stdin_behavior = .Ignore;
968		child.stdout_behavior = .Pipe;
969		child.stderr_behavior = .Pipe;
970
971		child.spawn() catch \|err\| debug.panic("Unable to spawn {s}: {s}\n", .{ zig_args.items[0], @errorName(err) });
972
973		var stdout_buf = ArrayList(u8).init(b.allocator);
974		var stderr_buf = ArrayList(u8).init(b.allocator);
975
976		child.stdout.?.reader().readAllArrayList(&stdout_buf, max_stdout_size) catch unreachable;
977		child.stderr.?.reader().readAllArrayList(&stderr_buf, max_stdout_size) catch unreachable;
978
979		const term = child.wait() catch \|err\| {
980		debug.panic("Unable to spawn {s}: {s}\n", .{ zig_args.items[0], @errorName(err) });
981		};
982		switch (term) {
983		.Exited => \|code\| {
984		if (code == 0) {
985		printInvocation(zig_args.items);
986		return error.CompilationIncorrectlySucceeded;
987		}
988		},
989		else => {
990		warn("Process {s} terminated unexpectedly\n", .{b.zig_exe});
991		printInvocation(zig_args.items);
992		return error.TestFailed;
993		},
994		}
995
996		const stdout = stdout_buf.items;
997		const stderr = stderr_buf.items;
998
999		if (stdout.len != 0) {
1000		warn(
1001		\\
1002		\\Expected empty stdout, instead found:
1003		\\================================================
1004		\\{s}
1005		\\================================================
1006		\\
1007		, .{stdout});
1008		return error.TestFailed;
1009		}
1010
1011		var ok = true;
1012		if (self.case.expect_exact) {
1013		var err_iter = ErrLineIter.init(stderr);
1014		var i: usize = 0;
1015		ok = while (err_iter.next()) \|line\| : (i += 1) {
1016		if (i >= self.case.expected_errors.items.len) break false;
1017		const expected = self.case.expected_errors.items[i];
1018		if (mem.indexOf(u8, line, expected) == null) break false;
1019		continue;
1020		} else true;
1021
1022		ok = ok and i == self.case.expected_errors.items.len;
1023
1024		if (!ok) {
1025		warn("\n======== Expected these compile errors: ========\n", .{});
1026		for (self.case.expected_errors.items) \|expected\| {
1027		warn("{s}\n", .{expected});
1028		}
1029		}
1030		} else {
1031		for (self.case.expected_errors.items) \|expected\| {
1032		if (mem.indexOf(u8, stderr, expected) == null) {
1033		warn(
1034		\\
1035		\\=========== Expected compile error: ============
1036		\\{s}
1037		\\
1038		, .{expected});
1039		ok = false;
1040		break;
1041		}
1042		}
1043		}
1044
1045		if (!ok) {
1046		warn(
1047		\\================= Full output: =================
1048		\\{s}
1049		\\
1050		, .{stderr});
1051		return error.TestFailed;
1052		}
1053
1054		warn("OK\n", .{});
1055		}
1056		};
1057
1058		pub fn create(
1059		self: *CompileErrorContext,
1060		name: []const u8,
1061		source: []const u8,
1062		expected_lines: []const []const u8,
1063		) *TestCase {
1064		const tc = self.b.allocator.create(TestCase) catch unreachable;
1065		tc.* = TestCase{
1066		.name = name,
1067		.sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
1068		.expected_errors = ArrayList([]const u8).init(self.b.allocator),
1069		.expect_exact = false,
1070		.link_libc = false,
1071		.is_exe = false,
1072		.is_test = false,
1073		};
1074
1075		tc.addSourceFile("tmp.zig", source);
1076		var arg_i: usize = 0;
1077		while (arg_i < expected_lines.len) : (arg_i += 1) {
1078		tc.addExpectedError(expected_lines[arg_i]);
1079		}
1080		return tc;
1081		}
1082
1083		pub fn addC(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: []const []const u8) void {
1084		var tc = self.create(name, source, expected_lines);
1085		tc.link_libc = true;
1086		self.addCase(tc);
1087		}
1088
1089		pub fn addExe(
1090		self: *CompileErrorContext,
1091		name: []const u8,
1092		source: []const u8,
1093		expected_lines: []const []const u8,
1094		) void {
1095		var tc = self.create(name, source, expected_lines);
1096		tc.is_exe = true;
1097		self.addCase(tc);
1098		}
1099
1100		pub fn add(
1101		self: *CompileErrorContext,
1102		name: []const u8,
1103		source: []const u8,
1104		expected_lines: []const []const u8,
1105		) void {
1106		const tc = self.create(name, source, expected_lines);
1107		self.addCase(tc);
1108		}
1109
1110		pub fn addTest(
1111		self: *CompileErrorContext,
1112		name: []const u8,
1113		source: []const u8,
1114		expected_lines: []const []const u8,
1115		) void {
1116		const tc = self.create(name, source, expected_lines);
1117		tc.is_test = true;
1118		self.addCase(tc);
1119		}
1120
1121		pub fn addCase(self: CompileErrorContext, case: const TestCase) void {
1122		const b = self.b;
1123
1124		const annotated_case_name = fmt.allocPrint(self.b.allocator, "compile-error {s}", .{
1125		case.name,
1126		}) catch unreachable;
1127		if (self.test_filter) \|filter\| {
1128		if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
1129		}
1130		const write_src = b.addWriteFiles();
1131		for (case.sources.items) \|src_file\| {
1132		write_src.add(src_file.filename, src_file.source);
1133		}
1134
1135		const compile_and_cmp_errors = CompileCmpOutputStep.create(self, annotated_case_name, case, .Debug, write_src);
1136		compile_and_cmp_errors.step.dependOn(&write_src.step);
1137		self.step.dependOn(&compile_and_cmp_errors.step);
1138		}
1139		};
1140
1141	827	pub const StandaloneContext = struct {
1142	828	b: *build.Builder,
1143	829	step: *build.Step,
...	...	@@ -1312,13 +998,6 @@ pub const GenHContext = struct {
1312	998	}
1313	999	};
1314	1000
1315		fn printInvocation(args: []const []const u8) void {
1316		for (args) \|arg\| {
1317		warn("{s} ", .{arg});
1318		}
1319		warn("\n", .{});
1320		}
1321
1322	1001	pub fn create(
1323	1002	self: *GenHContext,
1324	1003	filename: []const u8,